diff --git a/go.mod b/go.mod index d19069bd3..251adc99d 100644 --- a/go.mod +++ b/go.mod @@ -6,10 +6,10 @@ require ( github.com/ghodss/yaml v1.0.0 github.com/gonum/graph v0.0.0-20170401004347-50b27dea7ebb github.com/google/go-cmp v0.5.9 - github.com/openshift/api v0.0.0-20230320211411-560b2fb170af + github.com/openshift/api v0.0.0-20230330150608-05635858d40f github.com/openshift/build-machinery-go v0.0.0-20220913142420-e25cf57ea46d github.com/openshift/client-go v0.0.0-20230120202327-72f107311084 - github.com/openshift/library-go v0.0.0-20230302173334-c5e706838384 + github.com/openshift/library-go v0.0.0-20230405224819-c1e9763926fb github.com/prometheus/client_golang v1.14.0 github.com/prometheus/common v0.37.0 github.com/spf13/cobra v1.6.0 diff --git a/go.sum b/go.sum index bf119def9..bcf6191e8 100644 --- a/go.sum +++ b/go.sum @@ -424,14 +424,14 @@ github.com/onsi/ginkgo/v2 v2.4.0 h1:+Ig9nvqgS5OBSACXNk15PLdp0U9XPYROt9CFzVdFGIs= github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.23.0 h1:/oxKu9c2HVap+F3PfKort2Hw5DEU+HGlW8n+tguWsys= -github.com/openshift/api v0.0.0-20230320211411-560b2fb170af h1:js8+NVUCTK7cz+IO6i9MnKfKU14QYSMgOiJYvqhAMM0= -github.com/openshift/api v0.0.0-20230320211411-560b2fb170af/go.mod h1:ctXNyWanKEjGj8sss1KjjHQ3ENKFm33FFnS5BKaIPh4= +github.com/openshift/api v0.0.0-20230330150608-05635858d40f h1:mGpCtfoehMcvmg/sSYLiv6nCbTl04cmtkUfYzP7H1AQ= +github.com/openshift/api v0.0.0-20230330150608-05635858d40f/go.mod h1:ctXNyWanKEjGj8sss1KjjHQ3ENKFm33FFnS5BKaIPh4= github.com/openshift/build-machinery-go v0.0.0-20220913142420-e25cf57ea46d h1:RR4ah7FfaPR1WePizm0jlrsbmPu91xQZnAsVVreQV1k= github.com/openshift/build-machinery-go v0.0.0-20220913142420-e25cf57ea46d/go.mod h1:b1BuldmJlbA/xYtdZvKi+7j5YGB44qJUJDZ9zwiNCfE= github.com/openshift/client-go v0.0.0-20230120202327-72f107311084 h1:66uaqNwA+qYyQDwsMWUfjjau8ezmg1dzCqub13KZOcE= github.com/openshift/client-go v0.0.0-20230120202327-72f107311084/go.mod h1:M3h9m001PWac3eAudGG3isUud6yBjr5XpzLYLLTlHKo= -github.com/openshift/library-go v0.0.0-20230302173334-c5e706838384 h1:lNyOAREdff+F246oiR7OUGMRQSYbS0OXYbNPMTJMO/4= -github.com/openshift/library-go v0.0.0-20230302173334-c5e706838384/go.mod h1:xO4nAf0qa56dgvEJWVD1WuwSJ8JWPU1TYLBQrlutWnE= +github.com/openshift/library-go v0.0.0-20230405224819-c1e9763926fb h1:yv/0B9Km8VD1ch9nYuzPVkWVtG2nVZa3IOrj89sTKR0= +github.com/openshift/library-go v0.0.0-20230405224819-c1e9763926fb/go.mod h1:tedJaJsajpyrlPVNoSfjOst6w2HHvvR4VPqKWeZzrbY= github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= diff --git a/pkg/operator/configobservation/configobservercontroller/observe_config_controller.go b/pkg/operator/configobservation/configobservercontroller/observe_config_controller.go index dbb128a52..9973ea0f6 100644 --- a/pkg/operator/configobservation/configobservercontroller/observe_config_controller.go +++ b/pkg/operator/configobservation/configobservercontroller/observe_config_controller.go @@ -5,6 +5,7 @@ import ( "k8s.io/client-go/tools/cache" configinformers "github.com/openshift/client-go/config/informers/externalversions" + operatorinformers "github.com/openshift/client-go/operator/informers/externalversions" libgocloudprovider "github.com/openshift/library-go/pkg/cloudprovider" "github.com/openshift/library-go/pkg/controller/factory" "github.com/openshift/library-go/pkg/operator/configobserver" @@ -13,6 +14,7 @@ import ( "github.com/openshift/library-go/pkg/operator/configobserver/featuregates" nodeobserver "github.com/openshift/library-go/pkg/operator/configobserver/node" "github.com/openshift/library-go/pkg/operator/configobserver/proxy" + storageobserver "github.com/openshift/library-go/pkg/operator/configobserver/storage" "github.com/openshift/library-go/pkg/operator/events" "github.com/openshift/library-go/pkg/operator/resourcesynccontroller" "github.com/openshift/library-go/pkg/operator/v1helpers" @@ -41,6 +43,7 @@ type ConfigObserver struct { func NewConfigObserver( operatorClient v1helpers.OperatorClient, configinformers configinformers.SharedInformerFactory, + operatorinformers operatorinformers.SharedInformerFactory, kubeInformersForNamespaces v1helpers.KubeInformersForNamespaces, resourceSyncer resourcesynccontroller.ResourceSyncer, eventRecorder events.Recorder, @@ -64,6 +67,7 @@ func NewConfigObserver( configinformers.Config().V1().Networks().Informer(), configinformers.Config().V1().Nodes().Informer(), configinformers.Config().V1().Proxies().Informer(), + operatorinformers.Operator().V1().Storages().Informer(), } for _, ns := range interestingNamespaces { informers = append(informers, kubeInformersForNamespaces.InformersFor(ns).Core().V1().ConfigMaps().Informer()) @@ -96,6 +100,7 @@ func NewConfigObserver( NodeLister_: configinformers.Config().V1().Nodes().Lister(), ProxyLister_: configinformers.Config().V1().Proxies().Lister(), APIServerLister_: configinformers.Config().V1().APIServers().Lister(), + StorageLister_: operatorinformers.Operator().V1().Storages().Lister(), ResourceSync: resourceSyncer, ConfigMapLister_: kubeInformersForNamespaces.ConfigMapLister(), @@ -110,6 +115,7 @@ func NewConfigObserver( configinformers.Config().V1().Networks().Informer().HasSynced, configinformers.Config().V1().Nodes().Informer().HasSynced, configinformers.Config().V1().Proxies().Informer().HasSynced, + operatorinformers.Operator().V1().Storages().Informer().HasSynced, ), }, informers, @@ -150,6 +156,7 @@ func NewConfigObserver( clustername.ObserveInfraID, libgoapiserver.ObserveTLSSecurityProfile, cloud.ObserveCloudVolumePlugin, + storageobserver.NewStorageObserveFunc([]string{"targetconfigcontroller", "storage"}), ), } diff --git a/pkg/operator/configobservation/interfaces.go b/pkg/operator/configobservation/interfaces.go index bd06ecc2b..c7c4de480 100644 --- a/pkg/operator/configobservation/interfaces.go +++ b/pkg/operator/configobservation/interfaces.go @@ -5,6 +5,7 @@ import ( "k8s.io/client-go/tools/cache" configlistersv1 "github.com/openshift/client-go/config/listers/config/v1" + operatorlistersv1 "github.com/openshift/client-go/operator/listers/operator/v1" "github.com/openshift/library-go/pkg/operator/configobserver/cloudprovider" "github.com/openshift/library-go/pkg/operator/resourcesynccontroller" ) @@ -19,6 +20,7 @@ type Listers struct { ProxyLister_ configlistersv1.ProxyLister ConfigMapLister_ corev1listers.ConfigMapLister APIServerLister_ configlistersv1.APIServerLister + StorageLister_ operatorlistersv1.StorageLister ResourceSync resourcesynccontroller.ResourceSyncer PreRunCachesSynced []cache.InformerSynced @@ -55,3 +57,7 @@ func (l Listers) ConfigMapLister() corev1listers.ConfigMapLister { func (l Listers) APIServerLister() configlistersv1.APIServerLister { return l.APIServerLister_ } + +func (l Listers) StorageLister() operatorlistersv1.StorageLister { + return l.StorageLister_ +} diff --git a/pkg/operator/starter.go b/pkg/operator/starter.go index eeb0e278f..5fefe83a2 100644 --- a/pkg/operator/starter.go +++ b/pkg/operator/starter.go @@ -11,6 +11,8 @@ import ( configv1client "github.com/openshift/client-go/config/clientset/versioned" configinformers "github.com/openshift/client-go/config/informers/externalversions" configinformersv1 "github.com/openshift/client-go/config/informers/externalversions/config/v1" + operatorv1client "github.com/openshift/client-go/operator/clientset/versioned" + operatorinformers "github.com/openshift/client-go/operator/informers/externalversions" "github.com/openshift/cluster-kube-controller-manager-operator/bindata" "github.com/openshift/cluster-kube-controller-manager-operator/pkg/operator/certrotationcontroller" "github.com/openshift/cluster-kube-controller-manager-operator/pkg/operator/configobservation/configobservercontroller" @@ -48,8 +50,13 @@ func RunOperator(ctx context.Context, cc *controllercmd.ControllerContext) error if err != nil { return err } + opClient, err := operatorv1client.NewForConfig(cc.KubeConfig) + if err != nil { + return err + } configInformers := configinformers.NewSharedInformerFactory(configClient, 10*time.Minute) + opInformers := operatorinformers.NewSharedInformerFactory(opClient, 10*time.Minute) kubeInformersForNamespaces := v1helpers.NewKubeInformersForNamespaces(kubeClient, "", operatorclient.GlobalUserSpecifiedConfigNamespace, @@ -79,6 +86,7 @@ func RunOperator(ctx context.Context, cc *controllercmd.ControllerContext) error configObserver, err := configobservercontroller.NewConfigObserver( operatorClient, configInformers, + opInformers, kubeInformersForNamespaces, resourceSyncController, cc.EventRecorder, @@ -255,6 +263,7 @@ func RunOperator(ctx context.Context, cc *controllercmd.ControllerContext) error }) configInformers.Start(ctx.Done()) + opInformers.Start(ctx.Done()) kubeInformersForNamespaces.Start(ctx.Done()) dynamicInformers.Start(ctx.Done()) diff --git a/pkg/operator/targetconfigcontroller/targetconfigcontroller.go b/pkg/operator/targetconfigcontroller/targetconfigcontroller.go index df94ce1b5..e0b86f7a3 100644 --- a/pkg/operator/targetconfigcontroller/targetconfigcontroller.go +++ b/pkg/operator/targetconfigcontroller/targetconfigcontroller.go @@ -648,11 +648,20 @@ func managePod(ctx context.Context, configMapsGetter corev1client.ConfigMapsGett return nil, false, fmt.Errorf("couldn't get the proxy config from observedConfig: %v", err) } - proxyEnvVars := proxyMapToEnvVars(proxyConfig) + proxyEnvVars := stringMapToEnvVars(proxyConfig) for i, container := range required.Spec.Containers { required.Spec.Containers[i].Env = append(container.Env, proxyEnvVars...) } + // Set OPENSHIFT_DO_VSPHERE_MIGRATION to 'true' if vSphere migration is enabled + storageConfig, _, err := unstructured.NestedStringMap(observedConfig, "targetconfigcontroller", "storage") + if err != nil { + return nil, false, fmt.Errorf("couldn't get the storage config from observedConfig: %v", err) + } + storageEnvVars := stringMapToEnvVars(storageConfig) + // this environment variable is only needed for kube-controller-manager + required.Spec.Containers[0].Env = append(required.Spec.Containers[0].Env, storageEnvVars...) + // set the env var to indicate that we want this vulnerable behavior. if !useSecureServiceCA { for i, container := range required.Spec.Containers { @@ -904,13 +913,13 @@ func ensureKubeControllerManagerTrustedCA(ctx context.Context, client corev1clie return err } -func proxyMapToEnvVars(proxyConfig map[string]string) []corev1.EnvVar { - if proxyConfig == nil { +func stringMapToEnvVars(stringMap map[string]string) []corev1.EnvVar { + if stringMap == nil { return nil } envVars := []corev1.EnvVar{} - for k, v := range proxyConfig { + for k, v := range stringMap { envVars = append(envVars, corev1.EnvVar{Name: k, Value: v}) } diff --git a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_apiserver-Default.crd.yaml b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_apiserver-Default.crd.yaml index 808fae375..7edc7f23a 100644 --- a/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_apiserver-Default.crd.yaml +++ b/vendor/github.com/openshift/api/config/v1/0000_10_config-operator_01_apiserver-Default.crd.yaml @@ -102,6 +102,7 @@ spec: - "" - identity - aescbc + - aesgcm servingCerts: description: servingCert is the TLS cert info for serving secure traffic. If not specified, operator managed certificates will be used for serving secure traffic. type: object diff --git a/vendor/github.com/openshift/api/config/v1/stable.apiserver.testsuite.yaml b/vendor/github.com/openshift/api/config/v1/stable.apiserver.testsuite.yaml index 632525236..75f846a3d 100644 --- a/vendor/github.com/openshift/api/config/v1/stable.apiserver.testsuite.yaml +++ b/vendor/github.com/openshift/api/config/v1/stable.apiserver.testsuite.yaml @@ -18,12 +18,19 @@ tests: profile: Default encryption: type: aescbc - - name: Should not be able to create encrypt with aesgcm. Yet. + - name: Should be able to create encrypt with aesgcm initial: | apiVersion: config.openshift.io/v1 kind: APIServer spec: encryption: type: aesgcm - expectedError: "spec.encryption.type: Unsupported value: \"aesgcm\": supported values: \"\", \"identity\", \"aescbc\"" + expected: | + apiVersion: config.openshift.io/v1 + kind: APIServer + spec: + audit: + profile: Default + encryption: + type: aesgcm diff --git a/vendor/github.com/openshift/api/config/v1/types_apiserver.go b/vendor/github.com/openshift/api/config/v1/types_apiserver.go index 9940755c3..f4b52a227 100644 --- a/vendor/github.com/openshift/api/config/v1/types_apiserver.go +++ b/vendor/github.com/openshift/api/config/v1/types_apiserver.go @@ -184,8 +184,7 @@ type APIServerEncryption struct { Type EncryptionType `json:"type,omitempty"` } -// +openshift:validation:FeatureSetAwareEnum:featureSet=Default,enum="";identity;aescbc -// +openshift:validation:FeatureSetAwareEnum:featureSet=TechPreviewNoUpgrade,enum="";identity;aescbc;aesgcm +// +kubebuilder:validation:Enum="";identity;aescbc;aesgcm type EncryptionType string const ( diff --git a/vendor/github.com/openshift/api/operator/v1/0000_50_cluster_storage_operator_01_crd.yaml b/vendor/github.com/openshift/api/operator/v1/0000_50_cluster_storage_operator_01_crd.yaml index 2bf181862..484576c1a 100644 --- a/vendor/github.com/openshift/api/operator/v1/0000_50_cluster_storage_operator_01_crd.yaml +++ b/vendor/github.com/openshift/api/operator/v1/0000_50_cluster_storage_operator_01_crd.yaml @@ -69,6 +69,19 @@ spec: type: object nullable: true x-kubernetes-preserve-unknown-fields: true + vsphereStorageDriver: + description: 'VSphereStorageDriver indicates the storage driver to use on VSphere clusters. Once this field is set to CSIWithMigrationDriver, it can not be changed. If this is empty, the platform will choose a good default, which may change over time without notice. DEPRECATED: This field will be removed in a future release.' + type: string + enum: + - "" + - LegacyDeprecatedInTreeDriver + - CSIWithMigrationDriver + x-kubernetes-validations: + - rule: self == oldSelf || oldSelf == "" || self == "CSIWithMigrationDriver" + message: VSphereStorageDriver can not be changed once it is set to CSIWithMigrationDriver + x-kubernetes-validations: + - rule: '!has(oldSelf.vsphereStorageDriver) || has(self.vsphereStorageDriver)' + message: VSphereStorageDriver is required once set status: description: status holds observed values from the cluster. They may not be overridden. type: object diff --git a/vendor/github.com/openshift/api/operator/v1/stable.storage.testsuite.yaml b/vendor/github.com/openshift/api/operator/v1/stable.storage.testsuite.yaml index 42903f22d..63a7ca454 100644 --- a/vendor/github.com/openshift/api/operator/v1/stable.storage.testsuite.yaml +++ b/vendor/github.com/openshift/api/operator/v1/stable.storage.testsuite.yaml @@ -14,3 +14,91 @@ tests: spec: logLevel: Normal operatorLogLevel: Normal + onUpdate: + - name: Should allow enabling CSI migration for vSphere + initial: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: {} # No spec is required + updated: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + expected: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + logLevel: Normal + operatorLogLevel: Normal + - name: Should allow disabling CSI migration for vSphere + initial: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: {} # No spec is required + updated: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: LegacyDeprecatedInTreeDriver + expected: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: LegacyDeprecatedInTreeDriver + logLevel: Normal + operatorLogLevel: Normal + - name: Should allow changing LegacyDeprecatedInTreeDriver to CSIWithMigrationDriver + initial: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: LegacyDeprecatedInTreeDriver + updated: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + expected: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + logLevel: Normal + operatorLogLevel: Normal + - name: Should not allow changing CSIWithMigrationDriver to LegacyDeprecatedInTreeDriver + initial: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + updated: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: LegacyDeprecatedInTreeDriver + expectedError: "VSphereStorageDriver can not be changed once it is set to CSIWithMigrationDriver" + - name: Should not allow changing CSIWithMigrationDriver to empty string + initial: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + updated: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: "" + expectedError: "VSphereStorageDriver can not be changed once it is set to CSIWithMigrationDriver" + - name: Should not allow unsetting VSphereStorageDriver once it is set + initial: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: + vsphereStorageDriver: CSIWithMigrationDriver + updated: | + apiVersion: operator.openshift.io/v1 + kind: Storage + spec: {} + expectedError: "VSphereStorageDriver is required once set" diff --git a/vendor/github.com/openshift/api/operator/v1/types_storage.go b/vendor/github.com/openshift/api/operator/v1/types_storage.go index 38ffe26d5..044c9c32a 100644 --- a/vendor/github.com/openshift/api/operator/v1/types_storage.go +++ b/vendor/github.com/openshift/api/operator/v1/types_storage.go @@ -26,9 +26,28 @@ type Storage struct { Status StorageStatus `json:"status"` } +// StorageDriverType indicates whether CSI migration should be enabled for drivers where it is optional. +// +kubebuilder:validation:Enum="";LegacyDeprecatedInTreeDriver;CSIWithMigrationDriver +type StorageDriverType string + +const ( + LegacyDeprecatedInTreeDriver StorageDriverType = "LegacyDeprecatedInTreeDriver" + CSIWithMigrationDriver StorageDriverType = "CSIWithMigrationDriver" +) + // StorageSpec is the specification of the desired behavior of the cluster storage operator. +// +kubebuilder:validation:XValidation:rule="!has(oldSelf.vsphereStorageDriver) || has(self.vsphereStorageDriver)", message="VSphereStorageDriver is required once set" type StorageSpec struct { OperatorSpec `json:",inline"` + + // VSphereStorageDriver indicates the storage driver to use on VSphere clusters. + // Once this field is set to CSIWithMigrationDriver, it can not be changed. + // If this is empty, the platform will choose a good default, + // which may change over time without notice. + // DEPRECATED: This field will be removed in a future release. + // +kubebuilder:validation:XValidation:rule="self == oldSelf || oldSelf == \"\" || self == \"CSIWithMigrationDriver\"",message="VSphereStorageDriver can not be changed once it is set to CSIWithMigrationDriver" + // +optional + VSphereStorageDriver StorageDriverType `json:"vsphereStorageDriver"` } // StorageStatus defines the observed status of the cluster storage operator. diff --git a/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go b/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go index bab435e0c..1248ffb1b 100644 --- a/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go +++ b/vendor/github.com/openshift/api/operator/v1/zz_generated.swagger_doc_generated.go @@ -1610,7 +1610,8 @@ func (StorageList) SwaggerDoc() map[string]string { } var map_StorageSpec = map[string]string{ - "": "StorageSpec is the specification of the desired behavior of the cluster storage operator.", + "": "StorageSpec is the specification of the desired behavior of the cluster storage operator.", + "vsphereStorageDriver": "VSphereStorageDriver indicates the storage driver to use on VSphere clusters. Once this field is set to CSIWithMigrationDriver, it can not be changed. If this is empty, the platform will choose a good default, which may change over time without notice. DEPRECATED: This field will be removed in a future release.", } func (StorageSpec) SwaggerDoc() map[string]string { diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicy.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicy.go new file mode 100644 index 000000000..2792bd8c6 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,231 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + internal "github.com/openshift/client-go/operator/applyconfigurations/internal" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + managedfields "k8s.io/apimachinery/pkg/util/managedfields" + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// ImageContentSourcePolicyApplyConfiguration represents an declarative configuration of the ImageContentSourcePolicy type for use +// with apply. +type ImageContentSourcePolicyApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *ImageContentSourcePolicySpecApplyConfiguration `json:"spec,omitempty"` +} + +// ImageContentSourcePolicy constructs an declarative configuration of the ImageContentSourcePolicy type for use with +// apply. +func ImageContentSourcePolicy(name string) *ImageContentSourcePolicyApplyConfiguration { + b := &ImageContentSourcePolicyApplyConfiguration{} + b.WithName(name) + b.WithKind("ImageContentSourcePolicy") + b.WithAPIVersion("operator.openshift.io/v1alpha1") + return b +} + +// ExtractImageContentSourcePolicy extracts the applied configuration owned by fieldManager from +// imageContentSourcePolicy. If no managedFields are found in imageContentSourcePolicy for fieldManager, a +// ImageContentSourcePolicyApplyConfiguration is returned with only the Name, Namespace (if applicable), +// APIVersion and Kind populated. It is possible that no managed fields were found for because other +// field managers have taken ownership of all the fields previously owned by fieldManager, or because +// the fieldManager never owned fields any fields. +// imageContentSourcePolicy must be a unmodified ImageContentSourcePolicy API object that was retrieved from the Kubernetes API. +// ExtractImageContentSourcePolicy provides a way to perform a extract/modify-in-place/apply workflow. +// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously +// applied if another fieldManager has updated or force applied any of the previously applied fields. +// Experimental! +func ExtractImageContentSourcePolicy(imageContentSourcePolicy *operatorv1alpha1.ImageContentSourcePolicy, fieldManager string) (*ImageContentSourcePolicyApplyConfiguration, error) { + return extractImageContentSourcePolicy(imageContentSourcePolicy, fieldManager, "") +} + +// ExtractImageContentSourcePolicyStatus is the same as ExtractImageContentSourcePolicy except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractImageContentSourcePolicyStatus(imageContentSourcePolicy *operatorv1alpha1.ImageContentSourcePolicy, fieldManager string) (*ImageContentSourcePolicyApplyConfiguration, error) { + return extractImageContentSourcePolicy(imageContentSourcePolicy, fieldManager, "status") +} + +func extractImageContentSourcePolicy(imageContentSourcePolicy *operatorv1alpha1.ImageContentSourcePolicy, fieldManager string, subresource string) (*ImageContentSourcePolicyApplyConfiguration, error) { + b := &ImageContentSourcePolicyApplyConfiguration{} + err := managedfields.ExtractInto(imageContentSourcePolicy, internal.Parser().Type("com.github.openshift.api.operator.v1alpha1.ImageContentSourcePolicy"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(imageContentSourcePolicy.Name) + + b.WithKind("ImageContentSourcePolicy") + b.WithAPIVersion("operator.openshift.io/v1alpha1") + return b, nil +} + +// WithKind sets the Kind field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Kind field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithKind(value string) *ImageContentSourcePolicyApplyConfiguration { + b.Kind = &value + return b +} + +// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the APIVersion field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithAPIVersion(value string) *ImageContentSourcePolicyApplyConfiguration { + b.APIVersion = &value + return b +} + +// WithName sets the Name field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Name field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithName(value string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Name = &value + return b +} + +// WithGenerateName sets the GenerateName field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the GenerateName field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithGenerateName(value string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.GenerateName = &value + return b +} + +// WithNamespace sets the Namespace field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Namespace field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithNamespace(value string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Namespace = &value + return b +} + +// WithUID sets the UID field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the UID field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithUID(value types.UID) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.UID = &value + return b +} + +// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the ResourceVersion field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithResourceVersion(value string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ResourceVersion = &value + return b +} + +// WithGeneration sets the Generation field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Generation field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithGeneration(value int64) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.Generation = &value + return b +} + +// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the CreationTimestamp field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithCreationTimestamp(value metav1.Time) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.CreationTimestamp = &value + return b +} + +// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionTimestamp field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionTimestamp = &value + return b +} + +// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.DeletionGracePeriodSeconds = &value + return b +} + +// WithLabels puts the entries into the Labels field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Labels field, +// overwriting an existing map entries in Labels field with the same key. +func (b *ImageContentSourcePolicyApplyConfiguration) WithLabels(entries map[string]string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Labels == nil && len(entries) > 0 { + b.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Labels[k] = v + } + return b +} + +// WithAnnotations puts the entries into the Annotations field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, the entries provided by each call will be put on the Annotations field, +// overwriting an existing map entries in Annotations field with the same key. +func (b *ImageContentSourcePolicyApplyConfiguration) WithAnnotations(entries map[string]string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.Annotations == nil && len(entries) > 0 { + b.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.Annotations[k] = v + } + return b +} + +// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the OwnerReferences field. +func (b *ImageContentSourcePolicyApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.OwnerReferences = append(b.OwnerReferences, *values[i]) + } + return b +} + +// WithFinalizers adds the given value to the Finalizers field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Finalizers field. +func (b *ImageContentSourcePolicyApplyConfiguration) WithFinalizers(values ...string) *ImageContentSourcePolicyApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.Finalizers = append(b.Finalizers, values[i]) + } + return b +} + +func (b *ImageContentSourcePolicyApplyConfiguration) ensureObjectMetaApplyConfigurationExists() { + if b.ObjectMetaApplyConfiguration == nil { + b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{} + } +} + +// WithSpec sets the Spec field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Spec field is set to the value of the last call. +func (b *ImageContentSourcePolicyApplyConfiguration) WithSpec(value *ImageContentSourcePolicySpecApplyConfiguration) *ImageContentSourcePolicyApplyConfiguration { + b.Spec = value + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicyspec.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicyspec.go new file mode 100644 index 000000000..b0ef66e74 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicyspec.go @@ -0,0 +1,28 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// ImageContentSourcePolicySpecApplyConfiguration represents an declarative configuration of the ImageContentSourcePolicySpec type for use +// with apply. +type ImageContentSourcePolicySpecApplyConfiguration struct { + RepositoryDigestMirrors []RepositoryDigestMirrorsApplyConfiguration `json:"repositoryDigestMirrors,omitempty"` +} + +// ImageContentSourcePolicySpecApplyConfiguration constructs an declarative configuration of the ImageContentSourcePolicySpec type for use with +// apply. +func ImageContentSourcePolicySpec() *ImageContentSourcePolicySpecApplyConfiguration { + return &ImageContentSourcePolicySpecApplyConfiguration{} +} + +// WithRepositoryDigestMirrors adds the given value to the RepositoryDigestMirrors field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the RepositoryDigestMirrors field. +func (b *ImageContentSourcePolicySpecApplyConfiguration) WithRepositoryDigestMirrors(values ...*RepositoryDigestMirrorsApplyConfiguration) *ImageContentSourcePolicySpecApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithRepositoryDigestMirrors") + } + b.RepositoryDigestMirrors = append(b.RepositoryDigestMirrors, *values[i]) + } + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/repositorydigestmirrors.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/repositorydigestmirrors.go new file mode 100644 index 000000000..1d4ae88c8 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/repositorydigestmirrors.go @@ -0,0 +1,34 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// RepositoryDigestMirrorsApplyConfiguration represents an declarative configuration of the RepositoryDigestMirrors type for use +// with apply. +type RepositoryDigestMirrorsApplyConfiguration struct { + Source *string `json:"source,omitempty"` + Mirrors []string `json:"mirrors,omitempty"` +} + +// RepositoryDigestMirrorsApplyConfiguration constructs an declarative configuration of the RepositoryDigestMirrors type for use with +// apply. +func RepositoryDigestMirrors() *RepositoryDigestMirrorsApplyConfiguration { + return &RepositoryDigestMirrorsApplyConfiguration{} +} + +// WithSource sets the Source field in the declarative configuration to the given value +// and returns the receiver, so that objects can be built by chaining "With" function invocations. +// If called multiple times, the Source field is set to the value of the last call. +func (b *RepositoryDigestMirrorsApplyConfiguration) WithSource(value string) *RepositoryDigestMirrorsApplyConfiguration { + b.Source = &value + return b +} + +// WithMirrors adds the given value to the Mirrors field in the declarative configuration +// and returns the receiver, so that objects can be build by chaining "With" function invocations. +// If called multiple times, values provided by each call will be appended to the Mirrors field. +func (b *RepositoryDigestMirrorsApplyConfiguration) WithMirrors(values ...string) *RepositoryDigestMirrorsApplyConfiguration { + for i := range values { + b.Mirrors = append(b.Mirrors, values[i]) + } + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/clientset.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/clientset.go new file mode 100644 index 000000000..12aafefac --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/clientset.go @@ -0,0 +1,118 @@ +// Code generated by client-gen. DO NOT EDIT. + +package versioned + +import ( + "fmt" + "net/http" + + operatorv1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1" + operatorv1alpha1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1" + discovery "k8s.io/client-go/discovery" + rest "k8s.io/client-go/rest" + flowcontrol "k8s.io/client-go/util/flowcontrol" +) + +type Interface interface { + Discovery() discovery.DiscoveryInterface + OperatorV1() operatorv1.OperatorV1Interface + OperatorV1alpha1() operatorv1alpha1.OperatorV1alpha1Interface +} + +// Clientset contains the clients for groups. Each group has exactly one +// version included in a Clientset. +type Clientset struct { + *discovery.DiscoveryClient + operatorV1 *operatorv1.OperatorV1Client + operatorV1alpha1 *operatorv1alpha1.OperatorV1alpha1Client +} + +// OperatorV1 retrieves the OperatorV1Client +func (c *Clientset) OperatorV1() operatorv1.OperatorV1Interface { + return c.operatorV1 +} + +// OperatorV1alpha1 retrieves the OperatorV1alpha1Client +func (c *Clientset) OperatorV1alpha1() operatorv1alpha1.OperatorV1alpha1Interface { + return c.operatorV1alpha1 +} + +// Discovery retrieves the DiscoveryClient +func (c *Clientset) Discovery() discovery.DiscoveryInterface { + if c == nil { + return nil + } + return c.DiscoveryClient +} + +// NewForConfig creates a new Clientset for the given config. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfig will generate a rate-limiter in configShallowCopy. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*Clientset, error) { + configShallowCopy := *c + + if configShallowCopy.UserAgent == "" { + configShallowCopy.UserAgent = rest.DefaultKubernetesUserAgent() + } + + // share the transport between all clients + httpClient, err := rest.HTTPClientFor(&configShallowCopy) + if err != nil { + return nil, err + } + + return NewForConfigAndClient(&configShallowCopy, httpClient) +} + +// NewForConfigAndClient creates a new Clientset for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfigAndClient will generate a rate-limiter in configShallowCopy. +func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) { + configShallowCopy := *c + if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { + if configShallowCopy.Burst <= 0 { + return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") + } + configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) + } + + var cs Clientset + var err error + cs.operatorV1, err = operatorv1.NewForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + cs.operatorV1alpha1, err = operatorv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + + cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } + return &cs, nil +} + +// NewForConfigOrDie creates a new Clientset for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *Clientset { + cs, err := NewForConfig(c) + if err != nil { + panic(err) + } + return cs +} + +// New creates a new Clientset for the given RESTClient. +func New(c rest.Interface) *Clientset { + var cs Clientset + cs.operatorV1 = operatorv1.New(c) + cs.operatorV1alpha1 = operatorv1alpha1.New(c) + + cs.DiscoveryClient = discovery.NewDiscoveryClient(c) + return &cs +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/doc.go new file mode 100644 index 000000000..0e0c2a890 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// This package has the automatically generated clientset. +package versioned diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/doc.go new file mode 100644 index 000000000..93a7ca4e0 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v1alpha1 diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go new file mode 100644 index 000000000..42ec352cf --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go @@ -0,0 +1,5 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +type ImageContentSourcePolicyExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/imagecontentsourcepolicy.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/imagecontentsourcepolicy.go new file mode 100644 index 000000000..97f0dd98b --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,181 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + json "encoding/json" + "fmt" + "time" + + v1alpha1 "github.com/openshift/api/operator/v1alpha1" + operatorv1alpha1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// ImageContentSourcePoliciesGetter has a method to return a ImageContentSourcePolicyInterface. +// A group's client should implement this interface. +type ImageContentSourcePoliciesGetter interface { + ImageContentSourcePolicies() ImageContentSourcePolicyInterface +} + +// ImageContentSourcePolicyInterface has methods to work with ImageContentSourcePolicy resources. +type ImageContentSourcePolicyInterface interface { + Create(ctx context.Context, imageContentSourcePolicy *v1alpha1.ImageContentSourcePolicy, opts v1.CreateOptions) (*v1alpha1.ImageContentSourcePolicy, error) + Update(ctx context.Context, imageContentSourcePolicy *v1alpha1.ImageContentSourcePolicy, opts v1.UpdateOptions) (*v1alpha1.ImageContentSourcePolicy, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.ImageContentSourcePolicy, error) + List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.ImageContentSourcePolicyList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ImageContentSourcePolicy, err error) + Apply(ctx context.Context, imageContentSourcePolicy *operatorv1alpha1.ImageContentSourcePolicyApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) + ImageContentSourcePolicyExpansion +} + +// imageContentSourcePolicies implements ImageContentSourcePolicyInterface +type imageContentSourcePolicies struct { + client rest.Interface +} + +// newImageContentSourcePolicies returns a ImageContentSourcePolicies +func newImageContentSourcePolicies(c *OperatorV1alpha1Client) *imageContentSourcePolicies { + return &imageContentSourcePolicies{ + client: c.RESTClient(), + } +} + +// Get takes name of the imageContentSourcePolicy, and returns the corresponding imageContentSourcePolicy object, and an error if there is any. +func (c *imageContentSourcePolicies) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + result = &v1alpha1.ImageContentSourcePolicy{} + err = c.client.Get(). + Resource("imagecontentsourcepolicies"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of ImageContentSourcePolicies that match those selectors. +func (c *imageContentSourcePolicies) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.ImageContentSourcePolicyList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1alpha1.ImageContentSourcePolicyList{} + err = c.client.Get(). + Resource("imagecontentsourcepolicies"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested imageContentSourcePolicies. +func (c *imageContentSourcePolicies) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("imagecontentsourcepolicies"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a imageContentSourcePolicy and creates it. Returns the server's representation of the imageContentSourcePolicy, and an error, if there is any. +func (c *imageContentSourcePolicies) Create(ctx context.Context, imageContentSourcePolicy *v1alpha1.ImageContentSourcePolicy, opts v1.CreateOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + result = &v1alpha1.ImageContentSourcePolicy{} + err = c.client.Post(). + Resource("imagecontentsourcepolicies"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(imageContentSourcePolicy). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a imageContentSourcePolicy and updates it. Returns the server's representation of the imageContentSourcePolicy, and an error, if there is any. +func (c *imageContentSourcePolicies) Update(ctx context.Context, imageContentSourcePolicy *v1alpha1.ImageContentSourcePolicy, opts v1.UpdateOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + result = &v1alpha1.ImageContentSourcePolicy{} + err = c.client.Put(). + Resource("imagecontentsourcepolicies"). + Name(imageContentSourcePolicy.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(imageContentSourcePolicy). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the imageContentSourcePolicy and deletes it. Returns an error if one occurs. +func (c *imageContentSourcePolicies) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("imagecontentsourcepolicies"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *imageContentSourcePolicies) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("imagecontentsourcepolicies"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched imageContentSourcePolicy. +func (c *imageContentSourcePolicies) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ImageContentSourcePolicy, err error) { + result = &v1alpha1.ImageContentSourcePolicy{} + err = c.client.Patch(pt). + Resource("imagecontentsourcepolicies"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} + +// Apply takes the given apply declarative configuration, applies it and returns the applied imageContentSourcePolicy. +func (c *imageContentSourcePolicies) Apply(ctx context.Context, imageContentSourcePolicy *operatorv1alpha1.ImageContentSourcePolicyApplyConfiguration, opts v1.ApplyOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + if imageContentSourcePolicy == nil { + return nil, fmt.Errorf("imageContentSourcePolicy provided to Apply must not be nil") + } + patchOpts := opts.ToPatchOptions() + data, err := json.Marshal(imageContentSourcePolicy) + if err != nil { + return nil, err + } + name := imageContentSourcePolicy.Name + if name == nil { + return nil, fmt.Errorf("imageContentSourcePolicy.Name must be provided to Apply") + } + result = &v1alpha1.ImageContentSourcePolicy{} + err = c.client.Patch(types.ApplyPatchType). + Resource("imagecontentsourcepolicies"). + Name(*name). + VersionedParams(&patchOpts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/operator_client.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/operator_client.go new file mode 100644 index 000000000..9ce627aa3 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/operator_client.go @@ -0,0 +1,91 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "net/http" + + v1alpha1 "github.com/openshift/api/operator/v1alpha1" + "github.com/openshift/client-go/operator/clientset/versioned/scheme" + rest "k8s.io/client-go/rest" +) + +type OperatorV1alpha1Interface interface { + RESTClient() rest.Interface + ImageContentSourcePoliciesGetter +} + +// OperatorV1alpha1Client is used to interact with features provided by the operator.openshift.io group. +type OperatorV1alpha1Client struct { + restClient rest.Interface +} + +func (c *OperatorV1alpha1Client) ImageContentSourcePolicies() ImageContentSourcePolicyInterface { + return newImageContentSourcePolicies(c) +} + +// NewForConfig creates a new OperatorV1alpha1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*OperatorV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new OperatorV1alpha1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OperatorV1alpha1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) + if err != nil { + return nil, err + } + return &OperatorV1alpha1Client{client}, nil +} + +// NewForConfigOrDie creates a new OperatorV1alpha1Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *OperatorV1alpha1Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new OperatorV1alpha1Client for the given RESTClient. +func New(c rest.Interface) *OperatorV1alpha1Client { + return &OperatorV1alpha1Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := v1alpha1.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = scheme.Codecs.WithoutConversion() + + if config.UserAgent == "" { + config.UserAgent = rest.DefaultKubernetesUserAgent() + } + + return nil +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *OperatorV1alpha1Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/factory.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/factory.go new file mode 100644 index 000000000..0ef02e9ee --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/factory.go @@ -0,0 +1,164 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package externalversions + +import ( + reflect "reflect" + sync "sync" + time "time" + + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + operator "github.com/openshift/client-go/operator/informers/externalversions/operator" + 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" +) + +// SharedInformerOption defines the functional option type for SharedInformerFactory. +type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory + +type sharedInformerFactory struct { + client versioned.Interface + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc + lock sync.Mutex + defaultResync time.Duration + customResync map[reflect.Type]time.Duration + + informers map[reflect.Type]cache.SharedIndexInformer + // startedInformers is used for tracking which informers have been started. + // This allows Start() to be called multiple times safely. + startedInformers map[reflect.Type]bool +} + +// WithCustomResyncConfig sets a custom resync period for the specified informer types. +func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + for k, v := range resyncConfig { + factory.customResync[reflect.TypeOf(k)] = v + } + return factory + } +} + +// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory. +func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.tweakListOptions = tweakListOptions + return factory + } +} + +// WithNamespace limits the SharedInformerFactory to the specified namespace. +func WithNamespace(namespace string) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.namespace = namespace + return factory + } +} + +// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces. +func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory { + return NewSharedInformerFactoryWithOptions(client, defaultResync) +} + +// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory. +// Listers obtained via this SharedInformerFactory will be subject to the same filters +// as specified here. +// Deprecated: Please use NewSharedInformerFactoryWithOptions instead +func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory { + return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions)) +} + +// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options. +func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory { + factory := &sharedInformerFactory{ + client: client, + namespace: v1.NamespaceAll, + defaultResync: defaultResync, + informers: make(map[reflect.Type]cache.SharedIndexInformer), + startedInformers: make(map[reflect.Type]bool), + customResync: make(map[reflect.Type]time.Duration), + } + + // Apply all options + for _, opt := range options { + factory = opt(factory) + } + + return factory +} + +// Start initializes all requested informers. +func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) { + f.lock.Lock() + defer f.lock.Unlock() + + for informerType, informer := range f.informers { + if !f.startedInformers[informerType] { + go informer.Run(stopCh) + f.startedInformers[informerType] = true + } + } +} + +// WaitForCacheSync waits for all started informers' cache were synced. +func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool { + informers := func() map[reflect.Type]cache.SharedIndexInformer { + f.lock.Lock() + defer f.lock.Unlock() + + informers := map[reflect.Type]cache.SharedIndexInformer{} + for informerType, informer := range f.informers { + if f.startedInformers[informerType] { + informers[informerType] = informer + } + } + return informers + }() + + res := map[reflect.Type]bool{} + for informType, informer := range informers { + res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced) + } + return res +} + +// InternalInformerFor returns the SharedIndexInformer for obj using an internal +// client. +func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer { + f.lock.Lock() + defer f.lock.Unlock() + + informerType := reflect.TypeOf(obj) + informer, exists := f.informers[informerType] + if exists { + return informer + } + + resyncPeriod, exists := f.customResync[informerType] + if !exists { + resyncPeriod = f.defaultResync + } + + informer = newFunc(f.client, resyncPeriod) + f.informers[informerType] = informer + + return informer +} + +// SharedInformerFactory provides shared informers for resources in all known +// API group versions. +type SharedInformerFactory interface { + internalinterfaces.SharedInformerFactory + ForResource(resource schema.GroupVersionResource) (GenericInformer, error) + WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool + + Operator() operator.Interface +} + +func (f *sharedInformerFactory) Operator() operator.Interface { + return operator.New(f, f.namespace, f.tweakListOptions) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/generic.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/generic.go new file mode 100644 index 000000000..34b76e3f8 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/generic.go @@ -0,0 +1,91 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package externalversions + +import ( + "fmt" + + v1 "github.com/openshift/api/operator/v1" + v1alpha1 "github.com/openshift/api/operator/v1alpha1" + schema "k8s.io/apimachinery/pkg/runtime/schema" + cache "k8s.io/client-go/tools/cache" +) + +// GenericInformer is type of SharedIndexInformer which will locate and delegate to other +// sharedInformers based on type +type GenericInformer interface { + Informer() cache.SharedIndexInformer + Lister() cache.GenericLister +} + +type genericInformer struct { + informer cache.SharedIndexInformer + resource schema.GroupResource +} + +// Informer returns the SharedIndexInformer. +func (f *genericInformer) Informer() cache.SharedIndexInformer { + return f.informer +} + +// Lister returns the GenericLister. +func (f *genericInformer) Lister() cache.GenericLister { + return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource) +} + +// ForResource gives generic access to a shared informer of the matching type +// TODO extend this to unknown resources with a client pool +func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) { + switch resource { + // Group=operator.openshift.io, Version=v1 + case v1.SchemeGroupVersion.WithResource("authentications"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Authentications().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("csisnapshotcontrollers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().CSISnapshotControllers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("cloudcredentials"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().CloudCredentials().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("clustercsidrivers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().ClusterCSIDrivers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("configs"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Configs().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("consoles"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Consoles().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("dnses"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().DNSes().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("etcds"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Etcds().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("ingresscontrollers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().IngressControllers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("insightsoperators"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().InsightsOperators().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("kubeapiservers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().KubeAPIServers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("kubecontrollermanagers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().KubeControllerManagers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("kubeschedulers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().KubeSchedulers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("kubestorageversionmigrators"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().KubeStorageVersionMigrators().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("networks"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Networks().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("openshiftapiservers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().OpenShiftAPIServers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("openshiftcontrollermanagers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().OpenShiftControllerManagers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("servicecas"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().ServiceCAs().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("servicecatalogapiservers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().ServiceCatalogAPIServers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("servicecatalogcontrollermanagers"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().ServiceCatalogControllerManagers().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("storages"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Storages().Informer()}, nil + + // Group=operator.openshift.io, Version=v1alpha1 + case v1alpha1.SchemeGroupVersion.WithResource("imagecontentsourcepolicies"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().ImageContentSourcePolicies().Informer()}, nil + + } + + return nil, fmt.Errorf("no informer found for %v", resource) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces/factory_interfaces.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces/factory_interfaces.go new file mode 100644 index 000000000..bf4618167 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces/factory_interfaces.go @@ -0,0 +1,24 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package internalinterfaces + +import ( + time "time" + + versioned "github.com/openshift/client-go/operator/clientset/versioned" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + cache "k8s.io/client-go/tools/cache" +) + +// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer. +type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer + +// SharedInformerFactory a small interface to allow for adding an informer without an import cycle +type SharedInformerFactory interface { + Start(stopCh <-chan struct{}) + InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer +} + +// TweakListOptionsFunc is a function that transforms a v1.ListOptions. +type TweakListOptionsFunc func(*v1.ListOptions) diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/interface.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/interface.go new file mode 100644 index 000000000..4da3da158 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/interface.go @@ -0,0 +1,38 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package operator + +import ( + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/informers/externalversions/operator/v1" + v1alpha1 "github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1" +) + +// Interface provides access to each of this group's versions. +type Interface interface { + // V1 provides access to shared informers for resources in V1. + V1() v1.Interface + // V1alpha1 provides access to shared informers for resources in V1alpha1. + V1alpha1() v1alpha1.Interface +} + +type group 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 &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} +} + +// V1 returns a new v1.Interface. +func (g *group) V1() v1.Interface { + return v1.New(g.factory, g.namespace, g.tweakListOptions) +} + +// V1alpha1 returns a new v1alpha1.Interface. +func (g *group) V1alpha1() v1alpha1.Interface { + return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/authentication.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/authentication.go new file mode 100644 index 000000000..5ba8a37c1 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/authentication.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// AuthenticationInformer provides access to a shared informer and lister for +// Authentications. +type AuthenticationInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.AuthenticationLister +} + +type authenticationInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewAuthenticationInformer constructs a new informer for Authentication 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 NewAuthenticationInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredAuthenticationInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredAuthenticationInformer constructs a new informer for Authentication 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 NewFilteredAuthenticationInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Authentications().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Authentications().Watch(context.TODO(), options) + }, + }, + &operatorv1.Authentication{}, + resyncPeriod, + indexers, + ) +} + +func (f *authenticationInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredAuthenticationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *authenticationInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.Authentication{}, f.defaultInformer) +} + +func (f *authenticationInformer) Lister() v1.AuthenticationLister { + return v1.NewAuthenticationLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/cloudcredential.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/cloudcredential.go new file mode 100644 index 000000000..f2e7c71d1 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/cloudcredential.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// CloudCredentialInformer provides access to a shared informer and lister for +// CloudCredentials. +type CloudCredentialInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.CloudCredentialLister +} + +type cloudCredentialInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewCloudCredentialInformer constructs a new informer for CloudCredential 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 NewCloudCredentialInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredCloudCredentialInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredCloudCredentialInformer constructs a new informer for CloudCredential 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 NewFilteredCloudCredentialInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().CloudCredentials().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().CloudCredentials().Watch(context.TODO(), options) + }, + }, + &operatorv1.CloudCredential{}, + resyncPeriod, + indexers, + ) +} + +func (f *cloudCredentialInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredCloudCredentialInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *cloudCredentialInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.CloudCredential{}, f.defaultInformer) +} + +func (f *cloudCredentialInformer) Lister() v1.CloudCredentialLister { + return v1.NewCloudCredentialLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/clustercsidriver.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/clustercsidriver.go new file mode 100644 index 000000000..8f3991e89 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/clustercsidriver.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// ClusterCSIDriverInformer provides access to a shared informer and lister for +// ClusterCSIDrivers. +type ClusterCSIDriverInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ClusterCSIDriverLister +} + +type clusterCSIDriverInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewClusterCSIDriverInformer constructs a new informer for ClusterCSIDriver 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 NewClusterCSIDriverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredClusterCSIDriverInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredClusterCSIDriverInformer constructs a new informer for ClusterCSIDriver 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 NewFilteredClusterCSIDriverInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ClusterCSIDrivers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ClusterCSIDrivers().Watch(context.TODO(), options) + }, + }, + &operatorv1.ClusterCSIDriver{}, + resyncPeriod, + indexers, + ) +} + +func (f *clusterCSIDriverInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredClusterCSIDriverInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *clusterCSIDriverInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.ClusterCSIDriver{}, f.defaultInformer) +} + +func (f *clusterCSIDriverInformer) Lister() v1.ClusterCSIDriverLister { + return v1.NewClusterCSIDriverLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/config.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/config.go new file mode 100644 index 000000000..b75116935 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/config.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// ConfigInformer provides access to a shared informer and lister for +// Configs. +type ConfigInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ConfigLister +} + +type configInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// 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, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredConfigInformer(client, 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, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Configs().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Configs().Watch(context.TODO(), options) + }, + }, + &operatorv1.Config{}, + resyncPeriod, + indexers, + ) +} + +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 *configInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.Config{}, f.defaultInformer) +} + +func (f *configInformer) Lister() v1.ConfigLister { + return v1.NewConfigLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/console.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/console.go new file mode 100644 index 000000000..587f0cc0c --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/console.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// ConsoleInformer provides access to a shared informer and lister for +// Consoles. +type ConsoleInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ConsoleLister +} + +type consoleInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewConsoleInformer constructs a new informer for Console 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 NewConsoleInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredConsoleInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredConsoleInformer constructs a new informer for Console 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 NewFilteredConsoleInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Consoles().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Consoles().Watch(context.TODO(), options) + }, + }, + &operatorv1.Console{}, + resyncPeriod, + indexers, + ) +} + +func (f *consoleInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredConsoleInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *consoleInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.Console{}, f.defaultInformer) +} + +func (f *consoleInformer) Lister() v1.ConsoleLister { + return v1.NewConsoleLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/csisnapshotcontroller.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/csisnapshotcontroller.go new file mode 100644 index 000000000..2319c7090 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/csisnapshotcontroller.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// CSISnapshotControllerInformer provides access to a shared informer and lister for +// CSISnapshotControllers. +type CSISnapshotControllerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.CSISnapshotControllerLister +} + +type cSISnapshotControllerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewCSISnapshotControllerInformer constructs a new informer for CSISnapshotController 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 NewCSISnapshotControllerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredCSISnapshotControllerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredCSISnapshotControllerInformer constructs a new informer for CSISnapshotController 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 NewFilteredCSISnapshotControllerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().CSISnapshotControllers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().CSISnapshotControllers().Watch(context.TODO(), options) + }, + }, + &operatorv1.CSISnapshotController{}, + resyncPeriod, + indexers, + ) +} + +func (f *cSISnapshotControllerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredCSISnapshotControllerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *cSISnapshotControllerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.CSISnapshotController{}, f.defaultInformer) +} + +func (f *cSISnapshotControllerInformer) Lister() v1.CSISnapshotControllerLister { + return v1.NewCSISnapshotControllerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/dns.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/dns.go new file mode 100644 index 000000000..8e718ddbc --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/dns.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// DNSInformer provides access to a shared informer and lister for +// DNSes. +type DNSInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.DNSLister +} + +type dNSInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewDNSInformer constructs a new informer for DNS 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 NewDNSInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredDNSInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredDNSInformer constructs a new informer for DNS 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 NewFilteredDNSInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().DNSes().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().DNSes().Watch(context.TODO(), options) + }, + }, + &operatorv1.DNS{}, + resyncPeriod, + indexers, + ) +} + +func (f *dNSInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredDNSInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *dNSInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.DNS{}, f.defaultInformer) +} + +func (f *dNSInformer) Lister() v1.DNSLister { + return v1.NewDNSLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/etcd.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/etcd.go new file mode 100644 index 000000000..bd4ee72db --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/etcd.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// EtcdInformer provides access to a shared informer and lister for +// Etcds. +type EtcdInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.EtcdLister +} + +type etcdInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewEtcdInformer constructs a new informer for Etcd 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 NewEtcdInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredEtcdInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredEtcdInformer constructs a new informer for Etcd 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 NewFilteredEtcdInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Etcds().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Etcds().Watch(context.TODO(), options) + }, + }, + &operatorv1.Etcd{}, + resyncPeriod, + indexers, + ) +} + +func (f *etcdInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredEtcdInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *etcdInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.Etcd{}, f.defaultInformer) +} + +func (f *etcdInformer) Lister() v1.EtcdLister { + return v1.NewEtcdLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/ingresscontroller.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/ingresscontroller.go new file mode 100644 index 000000000..06578a2b8 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/ingresscontroller.go @@ -0,0 +1,74 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// IngressControllerInformer provides access to a shared informer and lister for +// IngressControllers. +type IngressControllerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.IngressControllerLister +} + +type ingressControllerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc + namespace string +} + +// NewIngressControllerInformer constructs a new informer for IngressController 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 NewIngressControllerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredIngressControllerInformer(client, namespace, resyncPeriod, indexers, nil) +} + +// NewFilteredIngressControllerInformer constructs a new informer for IngressController 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 NewFilteredIngressControllerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().IngressControllers(namespace).List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().IngressControllers(namespace).Watch(context.TODO(), options) + }, + }, + &operatorv1.IngressController{}, + resyncPeriod, + indexers, + ) +} + +func (f *ingressControllerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredIngressControllerInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *ingressControllerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.IngressController{}, f.defaultInformer) +} + +func (f *ingressControllerInformer) Lister() v1.IngressControllerLister { + return v1.NewIngressControllerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/insightsoperator.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/insightsoperator.go new file mode 100644 index 000000000..422800665 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/insightsoperator.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// InsightsOperatorInformer provides access to a shared informer and lister for +// InsightsOperators. +type InsightsOperatorInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.InsightsOperatorLister +} + +type insightsOperatorInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewInsightsOperatorInformer constructs a new informer for InsightsOperator 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 NewInsightsOperatorInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredInsightsOperatorInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredInsightsOperatorInformer constructs a new informer for InsightsOperator 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 NewFilteredInsightsOperatorInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().InsightsOperators().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().InsightsOperators().Watch(context.TODO(), options) + }, + }, + &operatorv1.InsightsOperator{}, + resyncPeriod, + indexers, + ) +} + +func (f *insightsOperatorInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredInsightsOperatorInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *insightsOperatorInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.InsightsOperator{}, f.defaultInformer) +} + +func (f *insightsOperatorInformer) Lister() v1.InsightsOperatorLister { + return v1.NewInsightsOperatorLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/interface.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/interface.go new file mode 100644 index 000000000..59eb5eb93 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/interface.go @@ -0,0 +1,169 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // Authentications returns a AuthenticationInformer. + Authentications() AuthenticationInformer + // CSISnapshotControllers returns a CSISnapshotControllerInformer. + CSISnapshotControllers() CSISnapshotControllerInformer + // CloudCredentials returns a CloudCredentialInformer. + CloudCredentials() CloudCredentialInformer + // ClusterCSIDrivers returns a ClusterCSIDriverInformer. + ClusterCSIDrivers() ClusterCSIDriverInformer + // Configs returns a ConfigInformer. + Configs() ConfigInformer + // Consoles returns a ConsoleInformer. + Consoles() ConsoleInformer + // DNSes returns a DNSInformer. + DNSes() DNSInformer + // Etcds returns a EtcdInformer. + Etcds() EtcdInformer + // IngressControllers returns a IngressControllerInformer. + IngressControllers() IngressControllerInformer + // InsightsOperators returns a InsightsOperatorInformer. + InsightsOperators() InsightsOperatorInformer + // KubeAPIServers returns a KubeAPIServerInformer. + KubeAPIServers() KubeAPIServerInformer + // KubeControllerManagers returns a KubeControllerManagerInformer. + KubeControllerManagers() KubeControllerManagerInformer + // KubeSchedulers returns a KubeSchedulerInformer. + KubeSchedulers() KubeSchedulerInformer + // KubeStorageVersionMigrators returns a KubeStorageVersionMigratorInformer. + KubeStorageVersionMigrators() KubeStorageVersionMigratorInformer + // Networks returns a NetworkInformer. + Networks() NetworkInformer + // OpenShiftAPIServers returns a OpenShiftAPIServerInformer. + OpenShiftAPIServers() OpenShiftAPIServerInformer + // OpenShiftControllerManagers returns a OpenShiftControllerManagerInformer. + OpenShiftControllerManagers() OpenShiftControllerManagerInformer + // ServiceCAs returns a ServiceCAInformer. + ServiceCAs() ServiceCAInformer + // ServiceCatalogAPIServers returns a ServiceCatalogAPIServerInformer. + ServiceCatalogAPIServers() ServiceCatalogAPIServerInformer + // ServiceCatalogControllerManagers returns a ServiceCatalogControllerManagerInformer. + ServiceCatalogControllerManagers() ServiceCatalogControllerManagerInformer + // Storages returns a StorageInformer. + Storages() StorageInformer +} + +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} +} + +// Authentications returns a AuthenticationInformer. +func (v *version) Authentications() AuthenticationInformer { + return &authenticationInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// CSISnapshotControllers returns a CSISnapshotControllerInformer. +func (v *version) CSISnapshotControllers() CSISnapshotControllerInformer { + return &cSISnapshotControllerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// CloudCredentials returns a CloudCredentialInformer. +func (v *version) CloudCredentials() CloudCredentialInformer { + return &cloudCredentialInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// ClusterCSIDrivers returns a ClusterCSIDriverInformer. +func (v *version) ClusterCSIDrivers() ClusterCSIDriverInformer { + return &clusterCSIDriverInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Configs returns a ConfigInformer. +func (v *version) Configs() ConfigInformer { + return &configInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Consoles returns a ConsoleInformer. +func (v *version) Consoles() ConsoleInformer { + return &consoleInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// DNSes returns a DNSInformer. +func (v *version) DNSes() DNSInformer { + return &dNSInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Etcds returns a EtcdInformer. +func (v *version) Etcds() EtcdInformer { + return &etcdInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// IngressControllers returns a IngressControllerInformer. +func (v *version) IngressControllers() IngressControllerInformer { + return &ingressControllerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} +} + +// InsightsOperators returns a InsightsOperatorInformer. +func (v *version) InsightsOperators() InsightsOperatorInformer { + return &insightsOperatorInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// KubeAPIServers returns a KubeAPIServerInformer. +func (v *version) KubeAPIServers() KubeAPIServerInformer { + return &kubeAPIServerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// KubeControllerManagers returns a KubeControllerManagerInformer. +func (v *version) KubeControllerManagers() KubeControllerManagerInformer { + return &kubeControllerManagerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// KubeSchedulers returns a KubeSchedulerInformer. +func (v *version) KubeSchedulers() KubeSchedulerInformer { + return &kubeSchedulerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// KubeStorageVersionMigrators returns a KubeStorageVersionMigratorInformer. +func (v *version) KubeStorageVersionMigrators() KubeStorageVersionMigratorInformer { + return &kubeStorageVersionMigratorInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Networks returns a NetworkInformer. +func (v *version) Networks() NetworkInformer { + return &networkInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// OpenShiftAPIServers returns a OpenShiftAPIServerInformer. +func (v *version) OpenShiftAPIServers() OpenShiftAPIServerInformer { + return &openShiftAPIServerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// OpenShiftControllerManagers returns a OpenShiftControllerManagerInformer. +func (v *version) OpenShiftControllerManagers() OpenShiftControllerManagerInformer { + return &openShiftControllerManagerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// ServiceCAs returns a ServiceCAInformer. +func (v *version) ServiceCAs() ServiceCAInformer { + return &serviceCAInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// ServiceCatalogAPIServers returns a ServiceCatalogAPIServerInformer. +func (v *version) ServiceCatalogAPIServers() ServiceCatalogAPIServerInformer { + return &serviceCatalogAPIServerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// ServiceCatalogControllerManagers returns a ServiceCatalogControllerManagerInformer. +func (v *version) ServiceCatalogControllerManagers() ServiceCatalogControllerManagerInformer { + return &serviceCatalogControllerManagerInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Storages returns a StorageInformer. +func (v *version) Storages() StorageInformer { + return &storageInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubeapiserver.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubeapiserver.go new file mode 100644 index 000000000..6aa0cd4eb --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubeapiserver.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// KubeAPIServerInformer provides access to a shared informer and lister for +// KubeAPIServers. +type KubeAPIServerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.KubeAPIServerLister +} + +type kubeAPIServerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewKubeAPIServerInformer constructs a new informer for KubeAPIServer 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 NewKubeAPIServerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredKubeAPIServerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredKubeAPIServerInformer constructs a new informer for KubeAPIServer 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 NewFilteredKubeAPIServerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeAPIServers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeAPIServers().Watch(context.TODO(), options) + }, + }, + &operatorv1.KubeAPIServer{}, + resyncPeriod, + indexers, + ) +} + +func (f *kubeAPIServerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredKubeAPIServerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *kubeAPIServerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.KubeAPIServer{}, f.defaultInformer) +} + +func (f *kubeAPIServerInformer) Lister() v1.KubeAPIServerLister { + return v1.NewKubeAPIServerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubecontrollermanager.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubecontrollermanager.go new file mode 100644 index 000000000..277ea92fc --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubecontrollermanager.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// KubeControllerManagerInformer provides access to a shared informer and lister for +// KubeControllerManagers. +type KubeControllerManagerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.KubeControllerManagerLister +} + +type kubeControllerManagerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewKubeControllerManagerInformer constructs a new informer for KubeControllerManager 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 NewKubeControllerManagerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredKubeControllerManagerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredKubeControllerManagerInformer constructs a new informer for KubeControllerManager 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 NewFilteredKubeControllerManagerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeControllerManagers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeControllerManagers().Watch(context.TODO(), options) + }, + }, + &operatorv1.KubeControllerManager{}, + resyncPeriod, + indexers, + ) +} + +func (f *kubeControllerManagerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredKubeControllerManagerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *kubeControllerManagerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.KubeControllerManager{}, f.defaultInformer) +} + +func (f *kubeControllerManagerInformer) Lister() v1.KubeControllerManagerLister { + return v1.NewKubeControllerManagerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubescheduler.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubescheduler.go new file mode 100644 index 000000000..91d55bd53 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubescheduler.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// KubeSchedulerInformer provides access to a shared informer and lister for +// KubeSchedulers. +type KubeSchedulerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.KubeSchedulerLister +} + +type kubeSchedulerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewKubeSchedulerInformer constructs a new informer for KubeScheduler 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 NewKubeSchedulerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredKubeSchedulerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredKubeSchedulerInformer constructs a new informer for KubeScheduler 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 NewFilteredKubeSchedulerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeSchedulers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeSchedulers().Watch(context.TODO(), options) + }, + }, + &operatorv1.KubeScheduler{}, + resyncPeriod, + indexers, + ) +} + +func (f *kubeSchedulerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredKubeSchedulerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *kubeSchedulerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.KubeScheduler{}, f.defaultInformer) +} + +func (f *kubeSchedulerInformer) Lister() v1.KubeSchedulerLister { + return v1.NewKubeSchedulerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubestorageversionmigrator.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubestorageversionmigrator.go new file mode 100644 index 000000000..0be7bce90 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/kubestorageversionmigrator.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// KubeStorageVersionMigratorInformer provides access to a shared informer and lister for +// KubeStorageVersionMigrators. +type KubeStorageVersionMigratorInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.KubeStorageVersionMigratorLister +} + +type kubeStorageVersionMigratorInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewKubeStorageVersionMigratorInformer constructs a new informer for KubeStorageVersionMigrator 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 NewKubeStorageVersionMigratorInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredKubeStorageVersionMigratorInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredKubeStorageVersionMigratorInformer constructs a new informer for KubeStorageVersionMigrator 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 NewFilteredKubeStorageVersionMigratorInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeStorageVersionMigrators().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().KubeStorageVersionMigrators().Watch(context.TODO(), options) + }, + }, + &operatorv1.KubeStorageVersionMigrator{}, + resyncPeriod, + indexers, + ) +} + +func (f *kubeStorageVersionMigratorInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredKubeStorageVersionMigratorInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *kubeStorageVersionMigratorInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.KubeStorageVersionMigrator{}, f.defaultInformer) +} + +func (f *kubeStorageVersionMigratorInformer) Lister() v1.KubeStorageVersionMigratorLister { + return v1.NewKubeStorageVersionMigratorLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/network.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/network.go new file mode 100644 index 000000000..7f9e7b59b --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/network.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// NetworkInformer provides access to a shared informer and lister for +// Networks. +type NetworkInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.NetworkLister +} + +type networkInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewNetworkInformer constructs a new informer for Network 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 NewNetworkInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredNetworkInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredNetworkInformer constructs a new informer for Network 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 NewFilteredNetworkInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Networks().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Networks().Watch(context.TODO(), options) + }, + }, + &operatorv1.Network{}, + resyncPeriod, + indexers, + ) +} + +func (f *networkInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredNetworkInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *networkInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.Network{}, f.defaultInformer) +} + +func (f *networkInformer) Lister() v1.NetworkLister { + return v1.NewNetworkLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/openshiftapiserver.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/openshiftapiserver.go new file mode 100644 index 000000000..ee75de02c --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/openshiftapiserver.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// OpenShiftAPIServerInformer provides access to a shared informer and lister for +// OpenShiftAPIServers. +type OpenShiftAPIServerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.OpenShiftAPIServerLister +} + +type openShiftAPIServerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewOpenShiftAPIServerInformer constructs a new informer for OpenShiftAPIServer 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 NewOpenShiftAPIServerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredOpenShiftAPIServerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredOpenShiftAPIServerInformer constructs a new informer for OpenShiftAPIServer 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 NewFilteredOpenShiftAPIServerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().OpenShiftAPIServers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().OpenShiftAPIServers().Watch(context.TODO(), options) + }, + }, + &operatorv1.OpenShiftAPIServer{}, + resyncPeriod, + indexers, + ) +} + +func (f *openShiftAPIServerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredOpenShiftAPIServerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *openShiftAPIServerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.OpenShiftAPIServer{}, f.defaultInformer) +} + +func (f *openShiftAPIServerInformer) Lister() v1.OpenShiftAPIServerLister { + return v1.NewOpenShiftAPIServerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/openshiftcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/openshiftcontrollermanager.go new file mode 100644 index 000000000..bea5c96bb --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/openshiftcontrollermanager.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// OpenShiftControllerManagerInformer provides access to a shared informer and lister for +// OpenShiftControllerManagers. +type OpenShiftControllerManagerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.OpenShiftControllerManagerLister +} + +type openShiftControllerManagerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewOpenShiftControllerManagerInformer constructs a new informer for OpenShiftControllerManager 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 NewOpenShiftControllerManagerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredOpenShiftControllerManagerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredOpenShiftControllerManagerInformer constructs a new informer for OpenShiftControllerManager 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 NewFilteredOpenShiftControllerManagerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().OpenShiftControllerManagers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().OpenShiftControllerManagers().Watch(context.TODO(), options) + }, + }, + &operatorv1.OpenShiftControllerManager{}, + resyncPeriod, + indexers, + ) +} + +func (f *openShiftControllerManagerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredOpenShiftControllerManagerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *openShiftControllerManagerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.OpenShiftControllerManager{}, f.defaultInformer) +} + +func (f *openShiftControllerManagerInformer) Lister() v1.OpenShiftControllerManagerLister { + return v1.NewOpenShiftControllerManagerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/serviceca.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/serviceca.go new file mode 100644 index 000000000..c75dd0a6f --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/serviceca.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// ServiceCAInformer provides access to a shared informer and lister for +// ServiceCAs. +type ServiceCAInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ServiceCALister +} + +type serviceCAInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewServiceCAInformer constructs a new informer for ServiceCA 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 NewServiceCAInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredServiceCAInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredServiceCAInformer constructs a new informer for ServiceCA 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 NewFilteredServiceCAInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ServiceCAs().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ServiceCAs().Watch(context.TODO(), options) + }, + }, + &operatorv1.ServiceCA{}, + resyncPeriod, + indexers, + ) +} + +func (f *serviceCAInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredServiceCAInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *serviceCAInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.ServiceCA{}, f.defaultInformer) +} + +func (f *serviceCAInformer) Lister() v1.ServiceCALister { + return v1.NewServiceCALister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/servicecatalogapiserver.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/servicecatalogapiserver.go new file mode 100644 index 000000000..af1852053 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/servicecatalogapiserver.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// ServiceCatalogAPIServerInformer provides access to a shared informer and lister for +// ServiceCatalogAPIServers. +type ServiceCatalogAPIServerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ServiceCatalogAPIServerLister +} + +type serviceCatalogAPIServerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewServiceCatalogAPIServerInformer constructs a new informer for ServiceCatalogAPIServer 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 NewServiceCatalogAPIServerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredServiceCatalogAPIServerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredServiceCatalogAPIServerInformer constructs a new informer for ServiceCatalogAPIServer 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 NewFilteredServiceCatalogAPIServerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ServiceCatalogAPIServers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ServiceCatalogAPIServers().Watch(context.TODO(), options) + }, + }, + &operatorv1.ServiceCatalogAPIServer{}, + resyncPeriod, + indexers, + ) +} + +func (f *serviceCatalogAPIServerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredServiceCatalogAPIServerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *serviceCatalogAPIServerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.ServiceCatalogAPIServer{}, f.defaultInformer) +} + +func (f *serviceCatalogAPIServerInformer) Lister() v1.ServiceCatalogAPIServerLister { + return v1.NewServiceCatalogAPIServerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/servicecatalogcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/servicecatalogcontrollermanager.go new file mode 100644 index 000000000..6f629dc4a --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/servicecatalogcontrollermanager.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// ServiceCatalogControllerManagerInformer provides access to a shared informer and lister for +// ServiceCatalogControllerManagers. +type ServiceCatalogControllerManagerInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.ServiceCatalogControllerManagerLister +} + +type serviceCatalogControllerManagerInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewServiceCatalogControllerManagerInformer constructs a new informer for ServiceCatalogControllerManager 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 NewServiceCatalogControllerManagerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredServiceCatalogControllerManagerInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredServiceCatalogControllerManagerInformer constructs a new informer for ServiceCatalogControllerManager 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 NewFilteredServiceCatalogControllerManagerInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ServiceCatalogControllerManagers().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().ServiceCatalogControllerManagers().Watch(context.TODO(), options) + }, + }, + &operatorv1.ServiceCatalogControllerManager{}, + resyncPeriod, + indexers, + ) +} + +func (f *serviceCatalogControllerManagerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredServiceCatalogControllerManagerInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *serviceCatalogControllerManagerInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.ServiceCatalogControllerManager{}, f.defaultInformer) +} + +func (f *serviceCatalogControllerManagerInformer) Lister() v1.ServiceCatalogControllerManagerLister { + return v1.NewServiceCatalogControllerManagerLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/storage.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/storage.go new file mode 100644 index 000000000..982ed1828 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/storage.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + operatorv1 "github.com/openshift/api/operator/v1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1 "github.com/openshift/client-go/operator/listers/operator/v1" + metav1 "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" +) + +// StorageInformer provides access to a shared informer and lister for +// Storages. +type StorageInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.StorageLister +} + +type storageInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewStorageInformer constructs a new informer for Storage 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 NewStorageInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredStorageInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredStorageInformer constructs a new informer for Storage 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 NewFilteredStorageInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Storages().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().Storages().Watch(context.TODO(), options) + }, + }, + &operatorv1.Storage{}, + resyncPeriod, + indexers, + ) +} + +func (f *storageInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredStorageInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *storageInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1.Storage{}, f.defaultInformer) +} + +func (f *storageInformer) Lister() v1.StorageLister { + return v1.NewStorageLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/imagecontentsourcepolicy.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/imagecontentsourcepolicy.go new file mode 100644 index 000000000..be4c20715 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + "context" + time "time" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + versioned "github.com/openshift/client-go/operator/clientset/versioned" + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" + v1alpha1 "github.com/openshift/client-go/operator/listers/operator/v1alpha1" + 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" +) + +// ImageContentSourcePolicyInformer provides access to a shared informer and lister for +// ImageContentSourcePolicies. +type ImageContentSourcePolicyInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1alpha1.ImageContentSourcePolicyLister +} + +type imageContentSourcePolicyInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewImageContentSourcePolicyInformer constructs a new informer for ImageContentSourcePolicy 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 NewImageContentSourcePolicyInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredImageContentSourcePolicyInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredImageContentSourcePolicyInformer constructs a new informer for ImageContentSourcePolicy 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 NewFilteredImageContentSourcePolicyInformer(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.OperatorV1alpha1().ImageContentSourcePolicies().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1alpha1().ImageContentSourcePolicies().Watch(context.TODO(), options) + }, + }, + &operatorv1alpha1.ImageContentSourcePolicy{}, + resyncPeriod, + indexers, + ) +} + +func (f *imageContentSourcePolicyInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredImageContentSourcePolicyInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *imageContentSourcePolicyInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&operatorv1alpha1.ImageContentSourcePolicy{}, f.defaultInformer) +} + +func (f *imageContentSourcePolicyInformer) Lister() v1alpha1.ImageContentSourcePolicyLister { + return v1alpha1.NewImageContentSourcePolicyLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/interface.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/interface.go new file mode 100644 index 000000000..43069d459 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/interface.go @@ -0,0 +1,29 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + internalinterfaces "github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // ImageContentSourcePolicies returns a ImageContentSourcePolicyInformer. + ImageContentSourcePolicies() ImageContentSourcePolicyInformer +} + +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} +} + +// ImageContentSourcePolicies returns a ImageContentSourcePolicyInformer. +func (v *version) ImageContentSourcePolicies() ImageContentSourcePolicyInformer { + return &imageContentSourcePolicyInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/authentication.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/authentication.go new file mode 100644 index 000000000..90c171102 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/authentication.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// AuthenticationLister helps list Authentications. +// All objects returned here must be treated as read-only. +type AuthenticationLister interface { + // List lists all Authentications in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Authentication, err error) + // Get retrieves the Authentication from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Authentication, error) + AuthenticationListerExpansion +} + +// authenticationLister implements the AuthenticationLister interface. +type authenticationLister struct { + indexer cache.Indexer +} + +// NewAuthenticationLister returns a new AuthenticationLister. +func NewAuthenticationLister(indexer cache.Indexer) AuthenticationLister { + return &authenticationLister{indexer: indexer} +} + +// List lists all Authentications in the indexer. +func (s *authenticationLister) List(selector labels.Selector) (ret []*v1.Authentication, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Authentication)) + }) + return ret, err +} + +// Get retrieves the Authentication from the index for a given name. +func (s *authenticationLister) Get(name string) (*v1.Authentication, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("authentication"), name) + } + return obj.(*v1.Authentication), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/cloudcredential.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/cloudcredential.go new file mode 100644 index 000000000..c0693c4c3 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/cloudcredential.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// CloudCredentialLister helps list CloudCredentials. +// All objects returned here must be treated as read-only. +type CloudCredentialLister interface { + // List lists all CloudCredentials in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.CloudCredential, err error) + // Get retrieves the CloudCredential from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.CloudCredential, error) + CloudCredentialListerExpansion +} + +// cloudCredentialLister implements the CloudCredentialLister interface. +type cloudCredentialLister struct { + indexer cache.Indexer +} + +// NewCloudCredentialLister returns a new CloudCredentialLister. +func NewCloudCredentialLister(indexer cache.Indexer) CloudCredentialLister { + return &cloudCredentialLister{indexer: indexer} +} + +// List lists all CloudCredentials in the indexer. +func (s *cloudCredentialLister) List(selector labels.Selector) (ret []*v1.CloudCredential, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.CloudCredential)) + }) + return ret, err +} + +// Get retrieves the CloudCredential from the index for a given name. +func (s *cloudCredentialLister) Get(name string) (*v1.CloudCredential, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("cloudcredential"), name) + } + return obj.(*v1.CloudCredential), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/clustercsidriver.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/clustercsidriver.go new file mode 100644 index 000000000..cac23118d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/clustercsidriver.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ClusterCSIDriverLister helps list ClusterCSIDrivers. +// All objects returned here must be treated as read-only. +type ClusterCSIDriverLister interface { + // List lists all ClusterCSIDrivers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.ClusterCSIDriver, err error) + // Get retrieves the ClusterCSIDriver from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.ClusterCSIDriver, error) + ClusterCSIDriverListerExpansion +} + +// clusterCSIDriverLister implements the ClusterCSIDriverLister interface. +type clusterCSIDriverLister struct { + indexer cache.Indexer +} + +// NewClusterCSIDriverLister returns a new ClusterCSIDriverLister. +func NewClusterCSIDriverLister(indexer cache.Indexer) ClusterCSIDriverLister { + return &clusterCSIDriverLister{indexer: indexer} +} + +// List lists all ClusterCSIDrivers in the indexer. +func (s *clusterCSIDriverLister) List(selector labels.Selector) (ret []*v1.ClusterCSIDriver, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.ClusterCSIDriver)) + }) + return ret, err +} + +// Get retrieves the ClusterCSIDriver from the index for a given name. +func (s *clusterCSIDriverLister) Get(name string) (*v1.ClusterCSIDriver, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("clustercsidriver"), name) + } + return obj.(*v1.ClusterCSIDriver), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/config.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/config.go new file mode 100644 index 000000000..251a8b5a2 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/config.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ConfigLister helps list Configs. +// All objects returned here must be treated as read-only. +type ConfigLister interface { + // List lists all Configs in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Config, err error) + // Get retrieves the Config from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Config, error) + ConfigListerExpansion +} + +// configLister implements the ConfigLister interface. +type configLister struct { + indexer cache.Indexer +} + +// NewConfigLister returns a new ConfigLister. +func NewConfigLister(indexer cache.Indexer) ConfigLister { + return &configLister{indexer: indexer} +} + +// List lists all Configs in the indexer. +func (s *configLister) List(selector labels.Selector) (ret []*v1.Config, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Config)) + }) + return ret, err +} + +// Get retrieves the Config from the index for a given name. +func (s *configLister) Get(name string) (*v1.Config, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("config"), name) + } + return obj.(*v1.Config), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/console.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/console.go new file mode 100644 index 000000000..fe5f26790 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/console.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ConsoleLister helps list Consoles. +// All objects returned here must be treated as read-only. +type ConsoleLister interface { + // List lists all Consoles in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Console, err error) + // Get retrieves the Console from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Console, error) + ConsoleListerExpansion +} + +// consoleLister implements the ConsoleLister interface. +type consoleLister struct { + indexer cache.Indexer +} + +// NewConsoleLister returns a new ConsoleLister. +func NewConsoleLister(indexer cache.Indexer) ConsoleLister { + return &consoleLister{indexer: indexer} +} + +// List lists all Consoles in the indexer. +func (s *consoleLister) List(selector labels.Selector) (ret []*v1.Console, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Console)) + }) + return ret, err +} + +// Get retrieves the Console from the index for a given name. +func (s *consoleLister) Get(name string) (*v1.Console, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("console"), name) + } + return obj.(*v1.Console), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/csisnapshotcontroller.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/csisnapshotcontroller.go new file mode 100644 index 000000000..42cf36802 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/csisnapshotcontroller.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// CSISnapshotControllerLister helps list CSISnapshotControllers. +// All objects returned here must be treated as read-only. +type CSISnapshotControllerLister interface { + // List lists all CSISnapshotControllers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.CSISnapshotController, err error) + // Get retrieves the CSISnapshotController from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.CSISnapshotController, error) + CSISnapshotControllerListerExpansion +} + +// cSISnapshotControllerLister implements the CSISnapshotControllerLister interface. +type cSISnapshotControllerLister struct { + indexer cache.Indexer +} + +// NewCSISnapshotControllerLister returns a new CSISnapshotControllerLister. +func NewCSISnapshotControllerLister(indexer cache.Indexer) CSISnapshotControllerLister { + return &cSISnapshotControllerLister{indexer: indexer} +} + +// List lists all CSISnapshotControllers in the indexer. +func (s *cSISnapshotControllerLister) List(selector labels.Selector) (ret []*v1.CSISnapshotController, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.CSISnapshotController)) + }) + return ret, err +} + +// Get retrieves the CSISnapshotController from the index for a given name. +func (s *cSISnapshotControllerLister) Get(name string) (*v1.CSISnapshotController, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("csisnapshotcontroller"), name) + } + return obj.(*v1.CSISnapshotController), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/dns.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/dns.go new file mode 100644 index 000000000..477267353 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/dns.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// DNSLister helps list DNSes. +// All objects returned here must be treated as read-only. +type DNSLister interface { + // List lists all DNSes in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.DNS, err error) + // Get retrieves the DNS from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.DNS, error) + DNSListerExpansion +} + +// dNSLister implements the DNSLister interface. +type dNSLister struct { + indexer cache.Indexer +} + +// NewDNSLister returns a new DNSLister. +func NewDNSLister(indexer cache.Indexer) DNSLister { + return &dNSLister{indexer: indexer} +} + +// List lists all DNSes in the indexer. +func (s *dNSLister) List(selector labels.Selector) (ret []*v1.DNS, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.DNS)) + }) + return ret, err +} + +// Get retrieves the DNS from the index for a given name. +func (s *dNSLister) Get(name string) (*v1.DNS, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("dns"), name) + } + return obj.(*v1.DNS), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/etcd.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/etcd.go new file mode 100644 index 000000000..2556eb58f --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/etcd.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// EtcdLister helps list Etcds. +// All objects returned here must be treated as read-only. +type EtcdLister interface { + // List lists all Etcds in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Etcd, err error) + // Get retrieves the Etcd from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Etcd, error) + EtcdListerExpansion +} + +// etcdLister implements the EtcdLister interface. +type etcdLister struct { + indexer cache.Indexer +} + +// NewEtcdLister returns a new EtcdLister. +func NewEtcdLister(indexer cache.Indexer) EtcdLister { + return &etcdLister{indexer: indexer} +} + +// List lists all Etcds in the indexer. +func (s *etcdLister) List(selector labels.Selector) (ret []*v1.Etcd, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Etcd)) + }) + return ret, err +} + +// Get retrieves the Etcd from the index for a given name. +func (s *etcdLister) Get(name string) (*v1.Etcd, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("etcd"), name) + } + return obj.(*v1.Etcd), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/expansion_generated.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/expansion_generated.go new file mode 100644 index 000000000..f7d082e1a --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/expansion_generated.go @@ -0,0 +1,91 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +// AuthenticationListerExpansion allows custom methods to be added to +// AuthenticationLister. +type AuthenticationListerExpansion interface{} + +// CSISnapshotControllerListerExpansion allows custom methods to be added to +// CSISnapshotControllerLister. +type CSISnapshotControllerListerExpansion interface{} + +// CloudCredentialListerExpansion allows custom methods to be added to +// CloudCredentialLister. +type CloudCredentialListerExpansion interface{} + +// ClusterCSIDriverListerExpansion allows custom methods to be added to +// ClusterCSIDriverLister. +type ClusterCSIDriverListerExpansion interface{} + +// ConfigListerExpansion allows custom methods to be added to +// ConfigLister. +type ConfigListerExpansion interface{} + +// ConsoleListerExpansion allows custom methods to be added to +// ConsoleLister. +type ConsoleListerExpansion interface{} + +// DNSListerExpansion allows custom methods to be added to +// DNSLister. +type DNSListerExpansion interface{} + +// EtcdListerExpansion allows custom methods to be added to +// EtcdLister. +type EtcdListerExpansion interface{} + +// IngressControllerListerExpansion allows custom methods to be added to +// IngressControllerLister. +type IngressControllerListerExpansion interface{} + +// IngressControllerNamespaceListerExpansion allows custom methods to be added to +// IngressControllerNamespaceLister. +type IngressControllerNamespaceListerExpansion interface{} + +// InsightsOperatorListerExpansion allows custom methods to be added to +// InsightsOperatorLister. +type InsightsOperatorListerExpansion interface{} + +// KubeAPIServerListerExpansion allows custom methods to be added to +// KubeAPIServerLister. +type KubeAPIServerListerExpansion interface{} + +// KubeControllerManagerListerExpansion allows custom methods to be added to +// KubeControllerManagerLister. +type KubeControllerManagerListerExpansion interface{} + +// KubeSchedulerListerExpansion allows custom methods to be added to +// KubeSchedulerLister. +type KubeSchedulerListerExpansion interface{} + +// KubeStorageVersionMigratorListerExpansion allows custom methods to be added to +// KubeStorageVersionMigratorLister. +type KubeStorageVersionMigratorListerExpansion interface{} + +// NetworkListerExpansion allows custom methods to be added to +// NetworkLister. +type NetworkListerExpansion interface{} + +// OpenShiftAPIServerListerExpansion allows custom methods to be added to +// OpenShiftAPIServerLister. +type OpenShiftAPIServerListerExpansion interface{} + +// OpenShiftControllerManagerListerExpansion allows custom methods to be added to +// OpenShiftControllerManagerLister. +type OpenShiftControllerManagerListerExpansion interface{} + +// ServiceCAListerExpansion allows custom methods to be added to +// ServiceCALister. +type ServiceCAListerExpansion interface{} + +// ServiceCatalogAPIServerListerExpansion allows custom methods to be added to +// ServiceCatalogAPIServerLister. +type ServiceCatalogAPIServerListerExpansion interface{} + +// ServiceCatalogControllerManagerListerExpansion allows custom methods to be added to +// ServiceCatalogControllerManagerLister. +type ServiceCatalogControllerManagerListerExpansion interface{} + +// StorageListerExpansion allows custom methods to be added to +// StorageLister. +type StorageListerExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/ingresscontroller.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/ingresscontroller.go new file mode 100644 index 000000000..386541f47 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/ingresscontroller.go @@ -0,0 +1,83 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// IngressControllerLister helps list IngressControllers. +// All objects returned here must be treated as read-only. +type IngressControllerLister interface { + // List lists all IngressControllers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.IngressController, err error) + // IngressControllers returns an object that can list and get IngressControllers. + IngressControllers(namespace string) IngressControllerNamespaceLister + IngressControllerListerExpansion +} + +// ingressControllerLister implements the IngressControllerLister interface. +type ingressControllerLister struct { + indexer cache.Indexer +} + +// NewIngressControllerLister returns a new IngressControllerLister. +func NewIngressControllerLister(indexer cache.Indexer) IngressControllerLister { + return &ingressControllerLister{indexer: indexer} +} + +// List lists all IngressControllers in the indexer. +func (s *ingressControllerLister) List(selector labels.Selector) (ret []*v1.IngressController, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.IngressController)) + }) + return ret, err +} + +// IngressControllers returns an object that can list and get IngressControllers. +func (s *ingressControllerLister) IngressControllers(namespace string) IngressControllerNamespaceLister { + return ingressControllerNamespaceLister{indexer: s.indexer, namespace: namespace} +} + +// IngressControllerNamespaceLister helps list and get IngressControllers. +// All objects returned here must be treated as read-only. +type IngressControllerNamespaceLister interface { + // List lists all IngressControllers in the indexer for a given namespace. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.IngressController, err error) + // Get retrieves the IngressController from the indexer for a given namespace and name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.IngressController, error) + IngressControllerNamespaceListerExpansion +} + +// ingressControllerNamespaceLister implements the IngressControllerNamespaceLister +// interface. +type ingressControllerNamespaceLister struct { + indexer cache.Indexer + namespace string +} + +// List lists all IngressControllers in the indexer for a given namespace. +func (s ingressControllerNamespaceLister) List(selector labels.Selector) (ret []*v1.IngressController, err error) { + err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1.IngressController)) + }) + return ret, err +} + +// Get retrieves the IngressController from the indexer for a given namespace and name. +func (s ingressControllerNamespaceLister) Get(name string) (*v1.IngressController, error) { + obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("ingresscontroller"), name) + } + return obj.(*v1.IngressController), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/insightsoperator.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/insightsoperator.go new file mode 100644 index 000000000..c00fc30df --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/insightsoperator.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// InsightsOperatorLister helps list InsightsOperators. +// All objects returned here must be treated as read-only. +type InsightsOperatorLister interface { + // List lists all InsightsOperators in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.InsightsOperator, err error) + // Get retrieves the InsightsOperator from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.InsightsOperator, error) + InsightsOperatorListerExpansion +} + +// insightsOperatorLister implements the InsightsOperatorLister interface. +type insightsOperatorLister struct { + indexer cache.Indexer +} + +// NewInsightsOperatorLister returns a new InsightsOperatorLister. +func NewInsightsOperatorLister(indexer cache.Indexer) InsightsOperatorLister { + return &insightsOperatorLister{indexer: indexer} +} + +// List lists all InsightsOperators in the indexer. +func (s *insightsOperatorLister) List(selector labels.Selector) (ret []*v1.InsightsOperator, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.InsightsOperator)) + }) + return ret, err +} + +// Get retrieves the InsightsOperator from the index for a given name. +func (s *insightsOperatorLister) Get(name string) (*v1.InsightsOperator, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("insightsoperator"), name) + } + return obj.(*v1.InsightsOperator), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubeapiserver.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubeapiserver.go new file mode 100644 index 000000000..ea4b8e151 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubeapiserver.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// KubeAPIServerLister helps list KubeAPIServers. +// All objects returned here must be treated as read-only. +type KubeAPIServerLister interface { + // List lists all KubeAPIServers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.KubeAPIServer, err error) + // Get retrieves the KubeAPIServer from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.KubeAPIServer, error) + KubeAPIServerListerExpansion +} + +// kubeAPIServerLister implements the KubeAPIServerLister interface. +type kubeAPIServerLister struct { + indexer cache.Indexer +} + +// NewKubeAPIServerLister returns a new KubeAPIServerLister. +func NewKubeAPIServerLister(indexer cache.Indexer) KubeAPIServerLister { + return &kubeAPIServerLister{indexer: indexer} +} + +// List lists all KubeAPIServers in the indexer. +func (s *kubeAPIServerLister) List(selector labels.Selector) (ret []*v1.KubeAPIServer, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.KubeAPIServer)) + }) + return ret, err +} + +// Get retrieves the KubeAPIServer from the index for a given name. +func (s *kubeAPIServerLister) Get(name string) (*v1.KubeAPIServer, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("kubeapiserver"), name) + } + return obj.(*v1.KubeAPIServer), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubecontrollermanager.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubecontrollermanager.go new file mode 100644 index 000000000..c04330ba0 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubecontrollermanager.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// KubeControllerManagerLister helps list KubeControllerManagers. +// All objects returned here must be treated as read-only. +type KubeControllerManagerLister interface { + // List lists all KubeControllerManagers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.KubeControllerManager, err error) + // Get retrieves the KubeControllerManager from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.KubeControllerManager, error) + KubeControllerManagerListerExpansion +} + +// kubeControllerManagerLister implements the KubeControllerManagerLister interface. +type kubeControllerManagerLister struct { + indexer cache.Indexer +} + +// NewKubeControllerManagerLister returns a new KubeControllerManagerLister. +func NewKubeControllerManagerLister(indexer cache.Indexer) KubeControllerManagerLister { + return &kubeControllerManagerLister{indexer: indexer} +} + +// List lists all KubeControllerManagers in the indexer. +func (s *kubeControllerManagerLister) List(selector labels.Selector) (ret []*v1.KubeControllerManager, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.KubeControllerManager)) + }) + return ret, err +} + +// Get retrieves the KubeControllerManager from the index for a given name. +func (s *kubeControllerManagerLister) Get(name string) (*v1.KubeControllerManager, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("kubecontrollermanager"), name) + } + return obj.(*v1.KubeControllerManager), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubescheduler.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubescheduler.go new file mode 100644 index 000000000..1bc183df6 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubescheduler.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// KubeSchedulerLister helps list KubeSchedulers. +// All objects returned here must be treated as read-only. +type KubeSchedulerLister interface { + // List lists all KubeSchedulers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.KubeScheduler, err error) + // Get retrieves the KubeScheduler from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.KubeScheduler, error) + KubeSchedulerListerExpansion +} + +// kubeSchedulerLister implements the KubeSchedulerLister interface. +type kubeSchedulerLister struct { + indexer cache.Indexer +} + +// NewKubeSchedulerLister returns a new KubeSchedulerLister. +func NewKubeSchedulerLister(indexer cache.Indexer) KubeSchedulerLister { + return &kubeSchedulerLister{indexer: indexer} +} + +// List lists all KubeSchedulers in the indexer. +func (s *kubeSchedulerLister) List(selector labels.Selector) (ret []*v1.KubeScheduler, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.KubeScheduler)) + }) + return ret, err +} + +// Get retrieves the KubeScheduler from the index for a given name. +func (s *kubeSchedulerLister) Get(name string) (*v1.KubeScheduler, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("kubescheduler"), name) + } + return obj.(*v1.KubeScheduler), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubestorageversionmigrator.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubestorageversionmigrator.go new file mode 100644 index 000000000..ed2c53c77 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubestorageversionmigrator.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// KubeStorageVersionMigratorLister helps list KubeStorageVersionMigrators. +// All objects returned here must be treated as read-only. +type KubeStorageVersionMigratorLister interface { + // List lists all KubeStorageVersionMigrators in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.KubeStorageVersionMigrator, err error) + // Get retrieves the KubeStorageVersionMigrator from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.KubeStorageVersionMigrator, error) + KubeStorageVersionMigratorListerExpansion +} + +// kubeStorageVersionMigratorLister implements the KubeStorageVersionMigratorLister interface. +type kubeStorageVersionMigratorLister struct { + indexer cache.Indexer +} + +// NewKubeStorageVersionMigratorLister returns a new KubeStorageVersionMigratorLister. +func NewKubeStorageVersionMigratorLister(indexer cache.Indexer) KubeStorageVersionMigratorLister { + return &kubeStorageVersionMigratorLister{indexer: indexer} +} + +// List lists all KubeStorageVersionMigrators in the indexer. +func (s *kubeStorageVersionMigratorLister) List(selector labels.Selector) (ret []*v1.KubeStorageVersionMigrator, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.KubeStorageVersionMigrator)) + }) + return ret, err +} + +// Get retrieves the KubeStorageVersionMigrator from the index for a given name. +func (s *kubeStorageVersionMigratorLister) Get(name string) (*v1.KubeStorageVersionMigrator, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("kubestorageversionmigrator"), name) + } + return obj.(*v1.KubeStorageVersionMigrator), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/network.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/network.go new file mode 100644 index 000000000..61e098fd4 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/network.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// NetworkLister helps list Networks. +// All objects returned here must be treated as read-only. +type NetworkLister interface { + // List lists all Networks in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Network, err error) + // Get retrieves the Network from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Network, error) + NetworkListerExpansion +} + +// networkLister implements the NetworkLister interface. +type networkLister struct { + indexer cache.Indexer +} + +// NewNetworkLister returns a new NetworkLister. +func NewNetworkLister(indexer cache.Indexer) NetworkLister { + return &networkLister{indexer: indexer} +} + +// List lists all Networks in the indexer. +func (s *networkLister) List(selector labels.Selector) (ret []*v1.Network, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Network)) + }) + return ret, err +} + +// Get retrieves the Network from the index for a given name. +func (s *networkLister) Get(name string) (*v1.Network, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("network"), name) + } + return obj.(*v1.Network), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftapiserver.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftapiserver.go new file mode 100644 index 000000000..014b98373 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftapiserver.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// OpenShiftAPIServerLister helps list OpenShiftAPIServers. +// All objects returned here must be treated as read-only. +type OpenShiftAPIServerLister interface { + // List lists all OpenShiftAPIServers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.OpenShiftAPIServer, err error) + // Get retrieves the OpenShiftAPIServer from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.OpenShiftAPIServer, error) + OpenShiftAPIServerListerExpansion +} + +// openShiftAPIServerLister implements the OpenShiftAPIServerLister interface. +type openShiftAPIServerLister struct { + indexer cache.Indexer +} + +// NewOpenShiftAPIServerLister returns a new OpenShiftAPIServerLister. +func NewOpenShiftAPIServerLister(indexer cache.Indexer) OpenShiftAPIServerLister { + return &openShiftAPIServerLister{indexer: indexer} +} + +// List lists all OpenShiftAPIServers in the indexer. +func (s *openShiftAPIServerLister) List(selector labels.Selector) (ret []*v1.OpenShiftAPIServer, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.OpenShiftAPIServer)) + }) + return ret, err +} + +// Get retrieves the OpenShiftAPIServer from the index for a given name. +func (s *openShiftAPIServerLister) Get(name string) (*v1.OpenShiftAPIServer, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("openshiftapiserver"), name) + } + return obj.(*v1.OpenShiftAPIServer), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftcontrollermanager.go new file mode 100644 index 000000000..e3523d79d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftcontrollermanager.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// OpenShiftControllerManagerLister helps list OpenShiftControllerManagers. +// All objects returned here must be treated as read-only. +type OpenShiftControllerManagerLister interface { + // List lists all OpenShiftControllerManagers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.OpenShiftControllerManager, err error) + // Get retrieves the OpenShiftControllerManager from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.OpenShiftControllerManager, error) + OpenShiftControllerManagerListerExpansion +} + +// openShiftControllerManagerLister implements the OpenShiftControllerManagerLister interface. +type openShiftControllerManagerLister struct { + indexer cache.Indexer +} + +// NewOpenShiftControllerManagerLister returns a new OpenShiftControllerManagerLister. +func NewOpenShiftControllerManagerLister(indexer cache.Indexer) OpenShiftControllerManagerLister { + return &openShiftControllerManagerLister{indexer: indexer} +} + +// List lists all OpenShiftControllerManagers in the indexer. +func (s *openShiftControllerManagerLister) List(selector labels.Selector) (ret []*v1.OpenShiftControllerManager, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.OpenShiftControllerManager)) + }) + return ret, err +} + +// Get retrieves the OpenShiftControllerManager from the index for a given name. +func (s *openShiftControllerManagerLister) Get(name string) (*v1.OpenShiftControllerManager, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("openshiftcontrollermanager"), name) + } + return obj.(*v1.OpenShiftControllerManager), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/serviceca.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/serviceca.go new file mode 100644 index 000000000..475ed96ee --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/serviceca.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ServiceCALister helps list ServiceCAs. +// All objects returned here must be treated as read-only. +type ServiceCALister interface { + // List lists all ServiceCAs in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.ServiceCA, err error) + // Get retrieves the ServiceCA from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.ServiceCA, error) + ServiceCAListerExpansion +} + +// serviceCALister implements the ServiceCALister interface. +type serviceCALister struct { + indexer cache.Indexer +} + +// NewServiceCALister returns a new ServiceCALister. +func NewServiceCALister(indexer cache.Indexer) ServiceCALister { + return &serviceCALister{indexer: indexer} +} + +// List lists all ServiceCAs in the indexer. +func (s *serviceCALister) List(selector labels.Selector) (ret []*v1.ServiceCA, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.ServiceCA)) + }) + return ret, err +} + +// Get retrieves the ServiceCA from the index for a given name. +func (s *serviceCALister) Get(name string) (*v1.ServiceCA, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("serviceca"), name) + } + return obj.(*v1.ServiceCA), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogapiserver.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogapiserver.go new file mode 100644 index 000000000..eace6a3ed --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogapiserver.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ServiceCatalogAPIServerLister helps list ServiceCatalogAPIServers. +// All objects returned here must be treated as read-only. +type ServiceCatalogAPIServerLister interface { + // List lists all ServiceCatalogAPIServers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.ServiceCatalogAPIServer, err error) + // Get retrieves the ServiceCatalogAPIServer from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.ServiceCatalogAPIServer, error) + ServiceCatalogAPIServerListerExpansion +} + +// serviceCatalogAPIServerLister implements the ServiceCatalogAPIServerLister interface. +type serviceCatalogAPIServerLister struct { + indexer cache.Indexer +} + +// NewServiceCatalogAPIServerLister returns a new ServiceCatalogAPIServerLister. +func NewServiceCatalogAPIServerLister(indexer cache.Indexer) ServiceCatalogAPIServerLister { + return &serviceCatalogAPIServerLister{indexer: indexer} +} + +// List lists all ServiceCatalogAPIServers in the indexer. +func (s *serviceCatalogAPIServerLister) List(selector labels.Selector) (ret []*v1.ServiceCatalogAPIServer, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.ServiceCatalogAPIServer)) + }) + return ret, err +} + +// Get retrieves the ServiceCatalogAPIServer from the index for a given name. +func (s *serviceCatalogAPIServerLister) Get(name string) (*v1.ServiceCatalogAPIServer, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("servicecatalogapiserver"), name) + } + return obj.(*v1.ServiceCatalogAPIServer), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogcontrollermanager.go new file mode 100644 index 000000000..07521be9f --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogcontrollermanager.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ServiceCatalogControllerManagerLister helps list ServiceCatalogControllerManagers. +// All objects returned here must be treated as read-only. +type ServiceCatalogControllerManagerLister interface { + // List lists all ServiceCatalogControllerManagers in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.ServiceCatalogControllerManager, err error) + // Get retrieves the ServiceCatalogControllerManager from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.ServiceCatalogControllerManager, error) + ServiceCatalogControllerManagerListerExpansion +} + +// serviceCatalogControllerManagerLister implements the ServiceCatalogControllerManagerLister interface. +type serviceCatalogControllerManagerLister struct { + indexer cache.Indexer +} + +// NewServiceCatalogControllerManagerLister returns a new ServiceCatalogControllerManagerLister. +func NewServiceCatalogControllerManagerLister(indexer cache.Indexer) ServiceCatalogControllerManagerLister { + return &serviceCatalogControllerManagerLister{indexer: indexer} +} + +// List lists all ServiceCatalogControllerManagers in the indexer. +func (s *serviceCatalogControllerManagerLister) List(selector labels.Selector) (ret []*v1.ServiceCatalogControllerManager, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.ServiceCatalogControllerManager)) + }) + return ret, err +} + +// Get retrieves the ServiceCatalogControllerManager from the index for a given name. +func (s *serviceCatalogControllerManagerLister) Get(name string) (*v1.ServiceCatalogControllerManager, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("servicecatalogcontrollermanager"), name) + } + return obj.(*v1.ServiceCatalogControllerManager), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/storage.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/storage.go new file mode 100644 index 000000000..130957f34 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/storage.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/openshift/api/operator/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// StorageLister helps list Storages. +// All objects returned here must be treated as read-only. +type StorageLister interface { + // List lists all Storages in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.Storage, err error) + // Get retrieves the Storage from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.Storage, error) + StorageListerExpansion +} + +// storageLister implements the StorageLister interface. +type storageLister struct { + indexer cache.Indexer +} + +// NewStorageLister returns a new StorageLister. +func NewStorageLister(indexer cache.Indexer) StorageLister { + return &storageLister{indexer: indexer} +} + +// List lists all Storages in the indexer. +func (s *storageLister) List(selector labels.Selector) (ret []*v1.Storage, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.Storage)) + }) + return ret, err +} + +// Get retrieves the Storage from the index for a given name. +func (s *storageLister) Get(name string) (*v1.Storage, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("storage"), name) + } + return obj.(*v1.Storage), nil +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/expansion_generated.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/expansion_generated.go new file mode 100644 index 000000000..4cd9e28ac --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/expansion_generated.go @@ -0,0 +1,7 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +// ImageContentSourcePolicyListerExpansion allows custom methods to be added to +// ImageContentSourcePolicyLister. +type ImageContentSourcePolicyListerExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/imagecontentsourcepolicy.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/imagecontentsourcepolicy.go new file mode 100644 index 000000000..e48814872 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,52 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1alpha1 "github.com/openshift/api/operator/v1alpha1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// ImageContentSourcePolicyLister helps list ImageContentSourcePolicies. +// All objects returned here must be treated as read-only. +type ImageContentSourcePolicyLister interface { + // List lists all ImageContentSourcePolicies in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1alpha1.ImageContentSourcePolicy, err error) + // Get retrieves the ImageContentSourcePolicy from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1alpha1.ImageContentSourcePolicy, error) + ImageContentSourcePolicyListerExpansion +} + +// imageContentSourcePolicyLister implements the ImageContentSourcePolicyLister interface. +type imageContentSourcePolicyLister struct { + indexer cache.Indexer +} + +// NewImageContentSourcePolicyLister returns a new ImageContentSourcePolicyLister. +func NewImageContentSourcePolicyLister(indexer cache.Indexer) ImageContentSourcePolicyLister { + return &imageContentSourcePolicyLister{indexer: indexer} +} + +// List lists all ImageContentSourcePolicies in the indexer. +func (s *imageContentSourcePolicyLister) List(selector labels.Selector) (ret []*v1alpha1.ImageContentSourcePolicy, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1alpha1.ImageContentSourcePolicy)) + }) + return ret, err +} + +// Get retrieves the ImageContentSourcePolicy from the index for a given name. +func (s *imageContentSourcePolicyLister) Get(name string) (*v1alpha1.ImageContentSourcePolicy, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1alpha1.Resource("imagecontentsourcepolicy"), name) + } + return obj.(*v1alpha1.ImageContentSourcePolicy), nil +} diff --git a/vendor/github.com/openshift/library-go/pkg/operator/configobserver/storage/OWNERS b/vendor/github.com/openshift/library-go/pkg/operator/configobserver/storage/OWNERS new file mode 100644 index 000000000..a391cc17d --- /dev/null +++ b/vendor/github.com/openshift/library-go/pkg/operator/configobserver/storage/OWNERS @@ -0,0 +1,4 @@ +approvers: + - bertinatto + - jsafrane +component: Storage diff --git a/vendor/github.com/openshift/library-go/pkg/operator/configobserver/storage/storage_operator.go b/vendor/github.com/openshift/library-go/pkg/operator/configobserver/storage/storage_operator.go new file mode 100644 index 000000000..1b5998f9a --- /dev/null +++ b/vendor/github.com/openshift/library-go/pkg/operator/configobserver/storage/storage_operator.go @@ -0,0 +1,79 @@ +package storage + +import ( + "reflect" + + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + + opv1 "github.com/openshift/api/operator/v1" + oplistersv1 "github.com/openshift/client-go/operator/listers/operator/v1" + "github.com/openshift/library-go/pkg/operator/configobserver" + "github.com/openshift/library-go/pkg/operator/events" +) + +const ( + storageOperatorName = "cluster" +) + +type StorageLister interface { + StorageLister() oplistersv1.StorageLister +} + +func NewStorageObserveFunc(configPath []string) configobserver.ObserveConfigFunc { + return (&observeStorageFlags{ + configPath: configPath, + }).ObserveStorageOperator +} + +type observeStorageFlags struct { + configPath []string +} + +// ObserveStorageOperator observes the storage.operator.openshift.io/cluster object and writes +// its content to an unstructured object in a string map at the path from the constructor +func (f *observeStorageFlags) ObserveStorageOperator(genericListers configobserver.Listers, recorder events.Recorder, existingConfig map[string]interface{}) (ret map[string]interface{}, _ []error) { + defer func() { + ret = configobserver.Pruned(ret, f.configPath) + }() + + storageLister := genericListers.(StorageLister) + + errs := []error{} + observedConfig := map[string]interface{}{} + storageOperator, err := storageLister.StorageLister().Get(storageOperatorName) + if errors.IsNotFound(err) { + recorder.Warningf("ObserveStorageOperator", "storage.%s/%s not found", opv1.GroupName, storageOperatorName) + return observedConfig, errs + } + if err != nil { + return existingConfig, append(errs, err) + } + + newStorageMap := storageToMap(storageOperator) + if len(newStorageMap) > 0 { + if err := unstructured.SetNestedStringMap(observedConfig, newStorageMap, f.configPath...); err != nil { + return existingConfig, append(errs, err) + } + } + + currentStorageMap, _, err := unstructured.NestedStringMap(existingConfig, f.configPath...) + if err != nil { + errs = append(errs, err) + // keep going on read error from existing config + } + + if !reflect.DeepEqual(currentStorageMap, newStorageMap) { + recorder.Eventf("ObserveStorageOperator", "storage changed to %q", newStorageMap) + } + + return observedConfig, errs +} + +func storageToMap(storage *opv1.Storage) map[string]string { + if storage.Spec.VSphereStorageDriver == opv1.CSIWithMigrationDriver { + return map[string]string{"OPENSHIFT_DO_VSPHERE_MIGRATION": "true"} + } + + return nil +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 260344f6a..b169fba5d 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -192,7 +192,7 @@ github.com/modern-go/reflect2 # github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 ## explicit github.com/munnerz/goautoneg -# github.com/openshift/api v0.0.0-20230320211411-560b2fb170af +# github.com/openshift/api v0.0.0-20230330150608-05635858d40f ## explicit; go 1.19 github.com/openshift/api github.com/openshift/api/apiserver @@ -290,14 +290,24 @@ github.com/openshift/client-go/config/listers/config/v1 github.com/openshift/client-go/config/listers/config/v1alpha1 github.com/openshift/client-go/operator/applyconfigurations/internal github.com/openshift/client-go/operator/applyconfigurations/operator/v1 +github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1 +github.com/openshift/client-go/operator/clientset/versioned github.com/openshift/client-go/operator/clientset/versioned/scheme github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1 +github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1 +github.com/openshift/client-go/operator/informers/externalversions +github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces +github.com/openshift/client-go/operator/informers/externalversions/operator +github.com/openshift/client-go/operator/informers/externalversions/operator/v1 +github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1 +github.com/openshift/client-go/operator/listers/operator/v1 +github.com/openshift/client-go/operator/listers/operator/v1alpha1 github.com/openshift/client-go/route/applyconfigurations/internal github.com/openshift/client-go/route/applyconfigurations/route/v1 github.com/openshift/client-go/route/clientset/versioned github.com/openshift/client-go/route/clientset/versioned/scheme github.com/openshift/client-go/route/clientset/versioned/typed/route/v1 -# github.com/openshift/library-go v0.0.0-20230302173334-c5e706838384 +# github.com/openshift/library-go v0.0.0-20230405224819-c1e9763926fb ## explicit; go 1.19 github.com/openshift/library-go/pkg/assets github.com/openshift/library-go/pkg/authorization/hardcodedauthorizer @@ -324,6 +334,7 @@ github.com/openshift/library-go/pkg/operator/configobserver/featuregates github.com/openshift/library-go/pkg/operator/configobserver/network github.com/openshift/library-go/pkg/operator/configobserver/node github.com/openshift/library-go/pkg/operator/configobserver/proxy +github.com/openshift/library-go/pkg/operator/configobserver/storage github.com/openshift/library-go/pkg/operator/encryption/crypto github.com/openshift/library-go/pkg/operator/encryption/state github.com/openshift/library-go/pkg/operator/events