diff --git a/cmd/start.go b/cmd/start.go index ee601fba2f..f8cf702362 100644 --- a/cmd/start.go +++ b/cmd/start.go @@ -39,7 +39,7 @@ func init() { cmd.PersistentFlags().StringVar(&opts.PromQLTarget.KubeSvc.Name, "metrics-service", opts.PromQLTarget.KubeSvc.Name, "The name of the remote PromQL query service. Must be specified when --use-dns-for-services is disabled.") cmd.PersistentFlags().BoolVar(&opts.PromQLTarget.UseDNS, "use-dns-for-services", opts.PromQLTarget.UseDNS, "Configures the CVO to use DNS for resolution of services in the cluster.") cmd.PersistentFlags().StringVar(&opts.PrometheusURLString, "metrics-url", opts.PrometheusURLString, "The URL used to access the remote PromQL query service.") - cmd.PersistentFlags().BoolVar(&opts.InjectClusterIdIntoPromQL, "hypershift", opts.InjectClusterIdIntoPromQL, "This options indicates whether the CVO is running inside a hosted control plane.") + cmd.PersistentFlags().BoolVar(&opts.HyperShift, "hypershift", opts.HyperShift, "This options indicates whether the CVO is running inside a hosted control plane.") cmd.PersistentFlags().StringVar(&opts.UpdateService, "update-service", opts.UpdateService, "The preferred update service. If set, this option overrides any upstream value configured in ClusterVersion spec.") cmd.PersistentFlags().StringSliceVar(&opts.AlwaysEnableCapabilities, "always-enable-capabilities", opts.AlwaysEnableCapabilities, "List of the cluster capabilities which will always be implicitly enabled.") rootCmd.AddCommand(cmd) diff --git a/pkg/cvo/configuration/configuration.go b/pkg/cvo/configuration/configuration.go new file mode 100644 index 0000000000..b967178a0b --- /dev/null +++ b/pkg/cvo/configuration/configuration.go @@ -0,0 +1,114 @@ +package configuration + +import ( + "context" + "fmt" + "time" + + apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/util/workqueue" + "k8s.io/klog/v2" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + operatorclientset "github.com/openshift/client-go/operator/clientset/versioned" + cvoclientv1alpha1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1" + operatorexternalversions "github.com/openshift/client-go/operator/informers/externalversions" + operatorlistersv1alpha1 "github.com/openshift/client-go/operator/listers/operator/v1alpha1" +) + +const ClusterVersionOperatorConfigurationName = "cluster" + +type ClusterVersionOperatorConfiguration struct { + queueKey string + // queue tracks checking for the CVO configuration. + // + // The type any is used to comply with the worker method of the cvo.Operator struct. + queue workqueue.TypedRateLimitingInterface[any] + + client cvoclientv1alpha1.ClusterVersionOperatorInterface + lister operatorlistersv1alpha1.ClusterVersionOperatorLister + factory operatorexternalversions.SharedInformerFactory + + started bool +} + +func (config *ClusterVersionOperatorConfiguration) Queue() workqueue.TypedRateLimitingInterface[any] { + return config.queue +} + +// clusterVersionOperatorEventHandler queues an update for the cluster version operator on any change to the given object. +// Callers should use this with an informer. +func (config *ClusterVersionOperatorConfiguration) clusterVersionOperatorEventHandler() cache.ResourceEventHandler { + return cache.ResourceEventHandlerFuncs{ + AddFunc: func(_ interface{}) { + config.queue.Add(config.queueKey) + }, + UpdateFunc: func(_, _ interface{}) { + config.queue.Add(config.queueKey) + }, + DeleteFunc: func(_ interface{}) { + config.queue.Add(config.queueKey) + }, + } +} + +// NewClusterVersionOperatorConfiguration returns ClusterVersionOperatorConfiguration, which might be used +// to synchronize with the ClusterVersionOperator resource. +func NewClusterVersionOperatorConfiguration(client operatorclientset.Interface, factory operatorexternalversions.SharedInformerFactory) *ClusterVersionOperatorConfiguration { + return &ClusterVersionOperatorConfiguration{ + queueKey: fmt.Sprintf("ClusterVersionOperator/%s", ClusterVersionOperatorConfigurationName), + queue: workqueue.NewTypedRateLimitingQueueWithConfig[any]( + workqueue.DefaultTypedControllerRateLimiter[any](), + workqueue.TypedRateLimitingQueueConfig[any]{Name: "configuration"}), + client: client.OperatorV1alpha1().ClusterVersionOperators(), + factory: factory, + } +} + +// Start initializes and starts the configuration's informers. Must be run before Sync is called. +// Blocks until informers caches are synchronized or the context is cancelled. +func (config *ClusterVersionOperatorConfiguration) Start(ctx context.Context) error { + informer := config.factory.Operator().V1alpha1().ClusterVersionOperators() + if _, err := informer.Informer().AddEventHandler(config.clusterVersionOperatorEventHandler()); err != nil { + return err + } + config.lister = informer.Lister() + + config.factory.Start(ctx.Done()) + synced := config.factory.WaitForCacheSync(ctx.Done()) + for _, ok := range synced { + if !ok { + return fmt.Errorf("caches failed to sync: %w", ctx.Err()) + } + } + + config.started = true + return nil +} + +func (config *ClusterVersionOperatorConfiguration) Sync(ctx context.Context, key string) error { + if !config.started { + panic("ClusterVersionOperatorConfiguration instance was not properly started before its synchronization.") + } + startTime := time.Now() + klog.V(2).Infof("Started syncing CVO configuration %q", key) + defer func() { + klog.V(2).Infof("Finished syncing CVO configuration (%v)", time.Since(startTime)) + }() + + desiredConfig, err := config.lister.Get(ClusterVersionOperatorConfigurationName) + if apierrors.IsNotFound(err) { + // TODO: Set default values + return nil + } + if err != nil { + return err + } + return config.sync(ctx, desiredConfig) +} + +func (config *ClusterVersionOperatorConfiguration) sync(_ context.Context, _ *operatorv1alpha1.ClusterVersionOperator) error { + klog.Infof("ClusterVersionOperator configuration has been synced") + return nil +} diff --git a/pkg/cvo/cvo.go b/pkg/cvo/cvo.go index 83f25be5dd..1c1552ef91 100644 --- a/pkg/cvo/cvo.go +++ b/pkg/cvo/cvo.go @@ -31,6 +31,8 @@ import ( clientset "github.com/openshift/client-go/config/clientset/versioned" configinformersv1 "github.com/openshift/client-go/config/informers/externalversions/config/v1" configlistersv1 "github.com/openshift/client-go/config/listers/config/v1" + operatorclientset "github.com/openshift/client-go/operator/clientset/versioned" + operatorexternalversions "github.com/openshift/client-go/operator/informers/externalversions" "github.com/openshift/library-go/pkg/manifest" "github.com/openshift/library-go/pkg/verify" "github.com/openshift/library-go/pkg/verify/store" @@ -43,6 +45,7 @@ import ( "github.com/openshift/cluster-version-operator/pkg/clusterconditions" "github.com/openshift/cluster-version-operator/pkg/clusterconditions/standard" "github.com/openshift/cluster-version-operator/pkg/customsignaturestore" + "github.com/openshift/cluster-version-operator/pkg/cvo/configuration" cvointernal "github.com/openshift/cluster-version-operator/pkg/cvo/internal" "github.com/openshift/cluster-version-operator/pkg/cvo/internal/dynamicclient" "github.com/openshift/cluster-version-operator/pkg/featuregates" @@ -93,9 +96,10 @@ type Operator struct { // releaseCreated, if set, is the timestamp of the current update. releaseCreated time.Time - client clientset.Interface - kubeClient kubernetes.Interface - eventRecorder record.EventRecorder + client clientset.Interface + kubeClient kubernetes.Interface + operatorClient operatorclientset.Interface + eventRecorder record.EventRecorder // minimumUpdateCheckInterval is the minimum duration to check for updates from // the update service. @@ -142,6 +146,9 @@ type Operator struct { // conditionRegistry is used to evaluate whether a particular condition is risky or not. conditionRegistry clusterconditions.ConditionRegistry + // hypershift signals whether the CVO is running inside a hosted control plane. + hypershift bool + // injectClusterIdIntoPromQL indicates whether the CVO should inject the cluster id // into PromQL queries while evaluating risks from conditional updates. This is needed // in HyperShift to differentiate between metrics from multiple hosted clusters in @@ -176,6 +183,9 @@ type Operator struct { // alwaysEnableCapabilities is a list of the cluster capabilities which should // always be implicitly enabled. alwaysEnableCapabilities []configv1.ClusterVersionCapability + + // configuration, if enabled, reconciles the ClusterVersionOperator configuration. + configuration *configuration.ClusterVersionOperatorConfiguration } // New returns a new cluster version operator. @@ -190,10 +200,13 @@ func New( cmConfigInformer informerscorev1.ConfigMapInformer, cmConfigManagedInformer informerscorev1.ConfigMapInformer, proxyInformer configinformersv1.ProxyInformer, + operatorInformerFactory operatorexternalversions.SharedInformerFactory, client clientset.Interface, kubeClient kubernetes.Interface, + operatorClient operatorclientset.Interface, exclude string, clusterProfile string, + hypershift bool, promqlTarget clusterconditions.PromQLTarget, injectClusterIdIntoPromQL bool, updateService string, @@ -219,11 +232,13 @@ func New( client: client, kubeClient: kubeClient, + operatorClient: operatorClient, eventRecorder: eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: namespace}), queue: workqueue.NewTypedRateLimitingQueueWithConfig[any](workqueue.DefaultTypedControllerRateLimiter[any](), workqueue.TypedRateLimitingQueueConfig[any]{Name: "clusterversion"}), availableUpdatesQueue: workqueue.NewTypedRateLimitingQueueWithConfig[any](workqueue.DefaultTypedControllerRateLimiter[any](), workqueue.TypedRateLimitingQueueConfig[any]{Name: "availableupdates"}), upgradeableQueue: workqueue.NewTypedRateLimitingQueueWithConfig[any](workqueue.DefaultTypedControllerRateLimiter[any](), workqueue.TypedRateLimitingQueueConfig[any]{Name: "upgradeable"}), + hypershift: hypershift, exclude: exclude, clusterProfile: clusterProfile, conditionRegistry: standard.NewConditionRegistry(promqlTarget), @@ -262,6 +277,8 @@ func New( // make sure this is initialized after all the listers are initialized optr.upgradeableChecks = optr.defaultUpgradeableChecks() + optr.configuration = configuration.NewClusterVersionOperatorConfiguration(operatorClient, operatorInformerFactory) + return optr, nil } @@ -408,6 +425,7 @@ func (optr *Operator) Run(runContext context.Context, shutdownContext context.Co defer optr.queue.ShutDown() defer optr.availableUpdatesQueue.ShutDown() defer optr.upgradeableQueue.ShutDown() + defer optr.configuration.Queue().ShutDown() stopCh := runContext.Done() klog.Infof("Starting ClusterVersionOperator with minimum reconcile period %s", optr.minimumUpdateCheckInterval) @@ -446,6 +464,23 @@ func (optr *Operator) Run(runContext context.Context, shutdownContext context.Co resultChannel <- asyncResult{name: "available updates"} }() + if optr.shouldReconcileCVOConfiguration() { + resultChannelCount++ + go func() { + defer utilruntime.HandleCrash() + if err := optr.configuration.Start(runContext); err != nil { + utilruntime.HandleError(fmt.Errorf("unable to initialize the CVO configuration sync: %v", err)) + } else { + wait.UntilWithContext(runContext, func(runContext context.Context) { + optr.worker(runContext, optr.configuration.Queue(), optr.configuration.Sync) + }, time.Second) + } + resultChannel <- asyncResult{name: "cvo configuration"} + }() + } else { + klog.Infof("The ClusterVersionOperatorConfiguration feature gate is disabled or HyperShift is detected; the configuration sync routine will not run.") + } + resultChannelCount++ go func() { defer utilruntime.HandleCrash() @@ -515,6 +550,7 @@ func (optr *Operator) Run(runContext context.Context, shutdownContext context.Co optr.queue.ShutDown() optr.availableUpdatesQueue.ShutDown() optr.upgradeableQueue.ShutDown() + optr.configuration.Queue().ShutDown() } } @@ -1011,3 +1047,11 @@ func (optr *Operator) HTTPClient() (*http.Client, error) { Transport: transport, }, nil } + +// shouldReconcileCVOConfiguration returns whether the CVO should reconcile its configuration using the API server. +// +// enabledFeatureGates must be initialized before the function is called. +func (optr *Operator) shouldReconcileCVOConfiguration() bool { + // The relevant CRD and CR are not applied in HyperShift, which configures the CVO via a configuration file + return optr.enabledFeatureGates.CVOConfiguration() && !optr.hypershift +} diff --git a/pkg/cvo/status_test.go b/pkg/cvo/status_test.go index c2aae33af4..8287a17ab2 100644 --- a/pkg/cvo/status_test.go +++ b/pkg/cvo/status_test.go @@ -202,6 +202,7 @@ type fakeRiFlags struct { unknownVersion bool reconciliationIssuesCondition bool statusReleaseArchitecture bool + cvoConfiguration bool } func (f fakeRiFlags) UnknownVersion() bool { @@ -216,6 +217,10 @@ func (f fakeRiFlags) StatusReleaseArchitecture() bool { return f.statusReleaseArchitecture } +func (f fakeRiFlags) CVOConfiguration() bool { + return f.cvoConfiguration +} + func TestUpdateClusterVersionStatus_UnknownVersionAndReconciliationIssues(t *testing.T) { ignoreLastTransitionTime := cmpopts.IgnoreFields(configv1.ClusterOperatorStatusCondition{}, "LastTransitionTime") diff --git a/pkg/featuregates/featuregates.go b/pkg/featuregates/featuregates.go index 533516c3fe..b91bcb9b43 100644 --- a/pkg/featuregates/featuregates.go +++ b/pkg/featuregates/featuregates.go @@ -29,6 +29,10 @@ type CvoGateChecker interface { // StatusReleaseArchitecture controls whether CVO populates // Release.Architecture in status properties like status.desired and status.history[]. StatusReleaseArchitecture() bool + + // CVOConfiguration controls whether the CVO reconciles the ClusterVersionOperator resource that corresponds + // to its configuration. + CVOConfiguration() bool } type panicOnUsageBeforeInitializationFunc func() @@ -56,6 +60,11 @@ func (p panicOnUsageBeforeInitializationFunc) UnknownVersion() bool { return false } +func (p panicOnUsageBeforeInitializationFunc) CVOConfiguration() bool { + p() + return false +} + // CvoGates contains flags that control CVO functionality gated by product feature gates. The // names do not correspond to product feature gates, the booleans here are "smaller" (product-level // gate will enable multiple CVO behaviors). @@ -68,6 +77,7 @@ type CvoGates struct { unknownVersion bool reconciliationIssuesCondition bool statusReleaseArchitecture bool + cvoConfiguration bool } func (c CvoGates) ReconciliationIssuesCondition() bool { @@ -82,6 +92,10 @@ func (c CvoGates) UnknownVersion() bool { return c.unknownVersion } +func (c CvoGates) CVOConfiguration() bool { + return c.cvoConfiguration +} + // DefaultCvoGates apply when actual features for given version are unknown func DefaultCvoGates(version string) CvoGates { return CvoGates{ @@ -89,6 +103,7 @@ func DefaultCvoGates(version string) CvoGates { unknownVersion: true, reconciliationIssuesCondition: false, statusReleaseArchitecture: false, + cvoConfiguration: false, } } @@ -110,6 +125,8 @@ func CvoGatesFromFeatureGate(gate *configv1.FeatureGate, version string) CvoGate enabledGates.reconciliationIssuesCondition = true case features.FeatureGateImageStreamImportMode: enabledGates.statusReleaseArchitecture = true + case features.FeatureGateCVOConfiguration: + enabledGates.cvoConfiguration = true } } for _, disabled := range g.Disabled { @@ -118,6 +135,8 @@ func CvoGatesFromFeatureGate(gate *configv1.FeatureGate, version string) CvoGate enabledGates.reconciliationIssuesCondition = false case features.FeatureGateImageStreamImportMode: enabledGates.statusReleaseArchitecture = false + case features.FeatureGateCVOConfiguration: + enabledGates.cvoConfiguration = false } } } diff --git a/pkg/start/start.go b/pkg/start/start.go index b026ba699f..daee3c77fc 100644 --- a/pkg/start/start.go +++ b/pkg/start/start.go @@ -17,6 +17,7 @@ import ( v1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/fields" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/informers" @@ -34,12 +35,15 @@ import ( configv1 "github.com/openshift/api/config/v1" clientset "github.com/openshift/client-go/config/clientset/versioned" "github.com/openshift/client-go/config/informers/externalversions" + operatorclientset "github.com/openshift/client-go/operator/clientset/versioned" + operatorexternalversions "github.com/openshift/client-go/operator/informers/externalversions" "github.com/openshift/library-go/pkg/config/clusterstatus" libgoleaderelection "github.com/openshift/library-go/pkg/config/leaderelection" "github.com/openshift/cluster-version-operator/pkg/autoupdate" "github.com/openshift/cluster-version-operator/pkg/clusterconditions" "github.com/openshift/cluster-version-operator/pkg/cvo" + "github.com/openshift/cluster-version-operator/pkg/cvo/configuration" "github.com/openshift/cluster-version-operator/pkg/featuregates" "github.com/openshift/cluster-version-operator/pkg/internal" "github.com/openshift/cluster-version-operator/pkg/payload" @@ -80,6 +84,8 @@ type Options struct { ClusterProfile string + HyperShift bool + // AlwaysEnableCapabilities is a list of cluster version capabilities // which will always be implicitly enabled. AlwaysEnableCapabilities []string @@ -157,6 +163,9 @@ func (o *Options) Run(ctx context.Context) error { return fmt.Errorf("--always-enable-capabilities was set with unknown capabilities: %v", unknownCaps) } + // Inject the cluster ID into PromQL queries in HyperShift + o.InjectClusterIdIntoPromQL = o.HyperShift + // parse the prometheus url var err error o.PromQLTarget.URL, err = url.Parse(o.PrometheusURLString) @@ -220,6 +229,7 @@ func (o *Options) run(ctx context.Context, controllerCtx *Context, lock resource controllerCtx.OpenshiftConfigInformerFactory.Start(informersDone) controllerCtx.OpenshiftConfigManagedInformerFactory.Start(informersDone) controllerCtx.InformerFactory.Start(informersDone) + controllerCtx.OperatorInformerFactory.Start(informersDone) allSynced := controllerCtx.CVInformerFactory.WaitForCacheSync(informersDone) for _, synced := range allSynced { @@ -390,6 +400,10 @@ func (cb *ClientBuilder) KubeClientOrDie(name string, configFns ...func(*rest.Co return kubernetes.NewForConfigOrDie(rest.AddUserAgent(cb.RestConfig(configFns...), name)) } +func (cb *ClientBuilder) OperatorClientOrDie(name string, configFns ...func(*rest.Config)) operatorclientset.Interface { + return operatorclientset.NewForConfigOrDie(rest.AddUserAgent(cb.RestConfig(configFns...), name)) +} + func newClientBuilder(kubeconfig string) (*ClientBuilder, error) { clientCfg := clientcmd.NewDefaultClientConfigLoadingRules() clientCfg.ExplicitPath = kubeconfig @@ -449,6 +463,7 @@ type Context struct { OpenshiftConfigInformerFactory informers.SharedInformerFactory OpenshiftConfigManagedInformerFactory informers.SharedInformerFactory InformerFactory externalversions.SharedInformerFactory + OperatorInformerFactory operatorexternalversions.SharedInformerFactory fgLister configlistersv1.FeatureGateLister } @@ -458,14 +473,18 @@ type Context struct { func (o *Options) NewControllerContext(cb *ClientBuilder, alwaysEnableCapabilities []configv1.ClusterVersionCapability) (*Context, error) { client := cb.ClientOrDie("shared-informer") kubeClient := cb.KubeClientOrDie(internal.ConfigNamespace, useProtobuf) + operatorClient := cb.OperatorClientOrDie("operator-client") cvInformer := externalversions.NewFilteredSharedInformerFactory(client, resyncPeriod(o.ResyncInterval), "", func(opts *metav1.ListOptions) { opts.FieldSelector = fmt.Sprintf("metadata.name=%s", o.Name) }) openshiftConfigInformer := informers.NewSharedInformerFactoryWithOptions(kubeClient, resyncPeriod(o.ResyncInterval), informers.WithNamespace(internal.ConfigNamespace)) openshiftConfigManagedInformer := informers.NewSharedInformerFactoryWithOptions(kubeClient, resyncPeriod(o.ResyncInterval), informers.WithNamespace(internal.ConfigManagedNamespace)) - sharedInformers := externalversions.NewSharedInformerFactory(client, resyncPeriod(o.ResyncInterval)) + operatorInformerFactory := operatorexternalversions.NewSharedInformerFactoryWithOptions(operatorClient, o.ResyncInterval, + operatorexternalversions.WithTweakListOptions(func(opts *metav1.ListOptions) { + opts.FieldSelector = fields.OneTermEqualSelector("metadata.name", configuration.ClusterVersionOperatorConfigurationName).String() + })) coInformer := sharedInformers.Config().V1().ClusterOperators() @@ -482,10 +501,13 @@ func (o *Options) NewControllerContext(cb *ClientBuilder, alwaysEnableCapabiliti openshiftConfigInformer.Core().V1().ConfigMaps(), openshiftConfigManagedInformer.Core().V1().ConfigMaps(), sharedInformers.Config().V1().Proxies(), + operatorInformerFactory, cb.ClientOrDie(o.Namespace), cvoKubeClient, + operatorClient, o.Exclude, o.ClusterProfile, + o.HyperShift, o.PromQLTarget, o.InjectClusterIdIntoPromQL, o.UpdateService, @@ -505,6 +527,7 @@ func (o *Options) NewControllerContext(cb *ClientBuilder, alwaysEnableCapabiliti OpenshiftConfigInformerFactory: openshiftConfigInformer, OpenshiftConfigManagedInformerFactory: openshiftConfigManagedInformer, InformerFactory: sharedInformers, + OperatorInformerFactory: operatorInformerFactory, CVO: cvo, StopOnFeatureGateChange: featureChangeStopper, diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/backupjobreference.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/backupjobreference.go new file mode 100644 index 0000000000..1f77b78640 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/backupjobreference.go @@ -0,0 +1,32 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// BackupJobReferenceApplyConfiguration represents a declarative configuration of the BackupJobReference type for use +// with apply. +type BackupJobReferenceApplyConfiguration struct { + Namespace *string `json:"namespace,omitempty"` + Name *string `json:"name,omitempty"` +} + +// BackupJobReferenceApplyConfiguration constructs a declarative configuration of the BackupJobReference type for use with +// apply. +func BackupJobReference() *BackupJobReferenceApplyConfiguration { + return &BackupJobReferenceApplyConfiguration{} +} + +// 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 *BackupJobReferenceApplyConfiguration) WithNamespace(value string) *BackupJobReferenceApplyConfiguration { + b.Namespace = &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 *BackupJobReferenceApplyConfiguration) WithName(value string) *BackupJobReferenceApplyConfiguration { + b.Name = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperator.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperator.go new file mode 100644 index 0000000000..079fca8812 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperator.go @@ -0,0 +1,246 @@ +// 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" +) + +// ClusterVersionOperatorApplyConfiguration represents a declarative configuration of the ClusterVersionOperator type for use +// with apply. +type ClusterVersionOperatorApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *ClusterVersionOperatorSpecApplyConfiguration `json:"spec,omitempty"` + Status *ClusterVersionOperatorStatusApplyConfiguration `json:"status,omitempty"` +} + +// ClusterVersionOperator constructs a declarative configuration of the ClusterVersionOperator type for use with +// apply. +func ClusterVersionOperator(name string) *ClusterVersionOperatorApplyConfiguration { + b := &ClusterVersionOperatorApplyConfiguration{} + b.WithName(name) + b.WithKind("ClusterVersionOperator") + b.WithAPIVersion("operator.openshift.io/v1alpha1") + return b +} + +// ExtractClusterVersionOperator extracts the applied configuration owned by fieldManager from +// clusterVersionOperator. If no managedFields are found in clusterVersionOperator for fieldManager, a +// ClusterVersionOperatorApplyConfiguration 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. +// clusterVersionOperator must be a unmodified ClusterVersionOperator API object that was retrieved from the Kubernetes API. +// ExtractClusterVersionOperator 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 ExtractClusterVersionOperator(clusterVersionOperator *operatorv1alpha1.ClusterVersionOperator, fieldManager string) (*ClusterVersionOperatorApplyConfiguration, error) { + return extractClusterVersionOperator(clusterVersionOperator, fieldManager, "") +} + +// ExtractClusterVersionOperatorStatus is the same as ExtractClusterVersionOperator except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractClusterVersionOperatorStatus(clusterVersionOperator *operatorv1alpha1.ClusterVersionOperator, fieldManager string) (*ClusterVersionOperatorApplyConfiguration, error) { + return extractClusterVersionOperator(clusterVersionOperator, fieldManager, "status") +} + +func extractClusterVersionOperator(clusterVersionOperator *operatorv1alpha1.ClusterVersionOperator, fieldManager string, subresource string) (*ClusterVersionOperatorApplyConfiguration, error) { + b := &ClusterVersionOperatorApplyConfiguration{} + err := managedfields.ExtractInto(clusterVersionOperator, internal.Parser().Type("com.github.openshift.api.operator.v1alpha1.ClusterVersionOperator"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(clusterVersionOperator.Name) + + b.WithKind("ClusterVersionOperator") + 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 *ClusterVersionOperatorApplyConfiguration) WithKind(value string) *ClusterVersionOperatorApplyConfiguration { + b.TypeMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithAPIVersion(value string) *ClusterVersionOperatorApplyConfiguration { + b.TypeMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithName(value string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithGenerateName(value string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithNamespace(value string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithUID(value types.UID) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithResourceVersion(value string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithGeneration(value int64) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithCreationTimestamp(value metav1.Time) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithLabels(entries map[string]string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.ObjectMetaApplyConfiguration.Labels == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithAnnotations(entries map[string]string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.ObjectMetaApplyConfiguration.Annotations == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.ObjectMetaApplyConfiguration.OwnerReferences = append(b.ObjectMetaApplyConfiguration.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 *ClusterVersionOperatorApplyConfiguration) WithFinalizers(values ...string) *ClusterVersionOperatorApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.ObjectMetaApplyConfiguration.Finalizers = append(b.ObjectMetaApplyConfiguration.Finalizers, values[i]) + } + return b +} + +func (b *ClusterVersionOperatorApplyConfiguration) 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 *ClusterVersionOperatorApplyConfiguration) WithSpec(value *ClusterVersionOperatorSpecApplyConfiguration) *ClusterVersionOperatorApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status 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 Status field is set to the value of the last call. +func (b *ClusterVersionOperatorApplyConfiguration) WithStatus(value *ClusterVersionOperatorStatusApplyConfiguration) *ClusterVersionOperatorApplyConfiguration { + b.Status = value + return b +} + +// GetName retrieves the value of the Name field in the declarative configuration. +func (b *ClusterVersionOperatorApplyConfiguration) GetName() *string { + b.ensureObjectMetaApplyConfigurationExists() + return b.ObjectMetaApplyConfiguration.Name +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperatorspec.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperatorspec.go new file mode 100644 index 0000000000..61a64b1ed7 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperatorspec.go @@ -0,0 +1,27 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "github.com/openshift/api/operator/v1" +) + +// ClusterVersionOperatorSpecApplyConfiguration represents a declarative configuration of the ClusterVersionOperatorSpec type for use +// with apply. +type ClusterVersionOperatorSpecApplyConfiguration struct { + OperatorLogLevel *v1.LogLevel `json:"operatorLogLevel,omitempty"` +} + +// ClusterVersionOperatorSpecApplyConfiguration constructs a declarative configuration of the ClusterVersionOperatorSpec type for use with +// apply. +func ClusterVersionOperatorSpec() *ClusterVersionOperatorSpecApplyConfiguration { + return &ClusterVersionOperatorSpecApplyConfiguration{} +} + +// WithOperatorLogLevel sets the OperatorLogLevel 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 OperatorLogLevel field is set to the value of the last call. +func (b *ClusterVersionOperatorSpecApplyConfiguration) WithOperatorLogLevel(value v1.LogLevel) *ClusterVersionOperatorSpecApplyConfiguration { + b.OperatorLogLevel = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperatorstatus.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperatorstatus.go new file mode 100644 index 0000000000..cad0232efc --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/clusterversionoperatorstatus.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// ClusterVersionOperatorStatusApplyConfiguration represents a declarative configuration of the ClusterVersionOperatorStatus type for use +// with apply. +type ClusterVersionOperatorStatusApplyConfiguration struct { + ObservedGeneration *int64 `json:"observedGeneration,omitempty"` +} + +// ClusterVersionOperatorStatusApplyConfiguration constructs a declarative configuration of the ClusterVersionOperatorStatus type for use with +// apply. +func ClusterVersionOperatorStatus() *ClusterVersionOperatorStatusApplyConfiguration { + return &ClusterVersionOperatorStatusApplyConfiguration{} +} + +// WithObservedGeneration sets the ObservedGeneration 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 ObservedGeneration field is set to the value of the last call. +func (b *ClusterVersionOperatorStatusApplyConfiguration) WithObservedGeneration(value int64) *ClusterVersionOperatorStatusApplyConfiguration { + b.ObservedGeneration = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackup.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackup.go new file mode 100644 index 0000000000..7f4a38dacf --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackup.go @@ -0,0 +1,246 @@ +// 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" +) + +// EtcdBackupApplyConfiguration represents a declarative configuration of the EtcdBackup type for use +// with apply. +type EtcdBackupApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *EtcdBackupSpecApplyConfiguration `json:"spec,omitempty"` + Status *EtcdBackupStatusApplyConfiguration `json:"status,omitempty"` +} + +// EtcdBackup constructs a declarative configuration of the EtcdBackup type for use with +// apply. +func EtcdBackup(name string) *EtcdBackupApplyConfiguration { + b := &EtcdBackupApplyConfiguration{} + b.WithName(name) + b.WithKind("EtcdBackup") + b.WithAPIVersion("operator.openshift.io/v1alpha1") + return b +} + +// ExtractEtcdBackup extracts the applied configuration owned by fieldManager from +// etcdBackup. If no managedFields are found in etcdBackup for fieldManager, a +// EtcdBackupApplyConfiguration 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. +// etcdBackup must be a unmodified EtcdBackup API object that was retrieved from the Kubernetes API. +// ExtractEtcdBackup 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 ExtractEtcdBackup(etcdBackup *operatorv1alpha1.EtcdBackup, fieldManager string) (*EtcdBackupApplyConfiguration, error) { + return extractEtcdBackup(etcdBackup, fieldManager, "") +} + +// ExtractEtcdBackupStatus is the same as ExtractEtcdBackup except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractEtcdBackupStatus(etcdBackup *operatorv1alpha1.EtcdBackup, fieldManager string) (*EtcdBackupApplyConfiguration, error) { + return extractEtcdBackup(etcdBackup, fieldManager, "status") +} + +func extractEtcdBackup(etcdBackup *operatorv1alpha1.EtcdBackup, fieldManager string, subresource string) (*EtcdBackupApplyConfiguration, error) { + b := &EtcdBackupApplyConfiguration{} + err := managedfields.ExtractInto(etcdBackup, internal.Parser().Type("com.github.openshift.api.operator.v1alpha1.EtcdBackup"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(etcdBackup.Name) + + b.WithKind("EtcdBackup") + 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 *EtcdBackupApplyConfiguration) WithKind(value string) *EtcdBackupApplyConfiguration { + b.TypeMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithAPIVersion(value string) *EtcdBackupApplyConfiguration { + b.TypeMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithName(value string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithGenerateName(value string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithNamespace(value string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithUID(value types.UID) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithResourceVersion(value string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithGeneration(value int64) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithCreationTimestamp(value metav1.Time) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithLabels(entries map[string]string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.ObjectMetaApplyConfiguration.Labels == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithAnnotations(entries map[string]string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.ObjectMetaApplyConfiguration.Annotations == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.ObjectMetaApplyConfiguration.OwnerReferences = append(b.ObjectMetaApplyConfiguration.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 *EtcdBackupApplyConfiguration) WithFinalizers(values ...string) *EtcdBackupApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.ObjectMetaApplyConfiguration.Finalizers = append(b.ObjectMetaApplyConfiguration.Finalizers, values[i]) + } + return b +} + +func (b *EtcdBackupApplyConfiguration) 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 *EtcdBackupApplyConfiguration) WithSpec(value *EtcdBackupSpecApplyConfiguration) *EtcdBackupApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status 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 Status field is set to the value of the last call. +func (b *EtcdBackupApplyConfiguration) WithStatus(value *EtcdBackupStatusApplyConfiguration) *EtcdBackupApplyConfiguration { + b.Status = value + return b +} + +// GetName retrieves the value of the Name field in the declarative configuration. +func (b *EtcdBackupApplyConfiguration) GetName() *string { + b.ensureObjectMetaApplyConfigurationExists() + return b.ObjectMetaApplyConfiguration.Name +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackupspec.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackupspec.go new file mode 100644 index 0000000000..ad094c7386 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackupspec.go @@ -0,0 +1,23 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +// EtcdBackupSpecApplyConfiguration represents a declarative configuration of the EtcdBackupSpec type for use +// with apply. +type EtcdBackupSpecApplyConfiguration struct { + PVCName *string `json:"pvcName,omitempty"` +} + +// EtcdBackupSpecApplyConfiguration constructs a declarative configuration of the EtcdBackupSpec type for use with +// apply. +func EtcdBackupSpec() *EtcdBackupSpecApplyConfiguration { + return &EtcdBackupSpecApplyConfiguration{} +} + +// WithPVCName sets the PVCName 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 PVCName field is set to the value of the last call. +func (b *EtcdBackupSpecApplyConfiguration) WithPVCName(value string) *EtcdBackupSpecApplyConfiguration { + b.PVCName = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackupstatus.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackupstatus.go new file mode 100644 index 0000000000..424924c10e --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/etcdbackupstatus.go @@ -0,0 +1,41 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "k8s.io/client-go/applyconfigurations/meta/v1" +) + +// EtcdBackupStatusApplyConfiguration represents a declarative configuration of the EtcdBackupStatus type for use +// with apply. +type EtcdBackupStatusApplyConfiguration struct { + Conditions []v1.ConditionApplyConfiguration `json:"conditions,omitempty"` + BackupJob *BackupJobReferenceApplyConfiguration `json:"backupJob,omitempty"` +} + +// EtcdBackupStatusApplyConfiguration constructs a declarative configuration of the EtcdBackupStatus type for use with +// apply. +func EtcdBackupStatus() *EtcdBackupStatusApplyConfiguration { + return &EtcdBackupStatusApplyConfiguration{} +} + +// WithConditions adds the given value to the Conditions 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 Conditions field. +func (b *EtcdBackupStatusApplyConfiguration) WithConditions(values ...*v1.ConditionApplyConfiguration) *EtcdBackupStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithConditions") + } + b.Conditions = append(b.Conditions, *values[i]) + } + return b +} + +// WithBackupJob sets the BackupJob 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 BackupJob field is set to the value of the last call. +func (b *EtcdBackupStatusApplyConfiguration) WithBackupJob(value *BackupJobReferenceApplyConfiguration) *EtcdBackupStatusApplyConfiguration { + b.BackupJob = value + return b +} 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 0000000000..91a03771d6 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,237 @@ +// 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 a 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 a 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.TypeMetaApplyConfiguration.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.TypeMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.Labels == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.Annotations == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.OwnerReferences = append(b.ObjectMetaApplyConfiguration.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.ObjectMetaApplyConfiguration.Finalizers = append(b.ObjectMetaApplyConfiguration.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 +} + +// GetName retrieves the value of the Name field in the declarative configuration. +func (b *ImageContentSourcePolicyApplyConfiguration) GetName() *string { + b.ensureObjectMetaApplyConfigurationExists() + return b.ObjectMetaApplyConfiguration.Name +} 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 0000000000..2363703619 --- /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 a declarative configuration of the ImageContentSourcePolicySpec type for use +// with apply. +type ImageContentSourcePolicySpecApplyConfiguration struct { + RepositoryDigestMirrors []RepositoryDigestMirrorsApplyConfiguration `json:"repositoryDigestMirrors,omitempty"` +} + +// ImageContentSourcePolicySpecApplyConfiguration constructs a 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/olm.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olm.go new file mode 100644 index 0000000000..2d475924ec --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olm.go @@ -0,0 +1,246 @@ +// 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" +) + +// OLMApplyConfiguration represents a declarative configuration of the OLM type for use +// with apply. +type OLMApplyConfiguration struct { + v1.TypeMetaApplyConfiguration `json:",inline"` + *v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"` + Spec *OLMSpecApplyConfiguration `json:"spec,omitempty"` + Status *OLMStatusApplyConfiguration `json:"status,omitempty"` +} + +// OLM constructs a declarative configuration of the OLM type for use with +// apply. +func OLM(name string) *OLMApplyConfiguration { + b := &OLMApplyConfiguration{} + b.WithName(name) + b.WithKind("OLM") + b.WithAPIVersion("operator.openshift.io/v1alpha1") + return b +} + +// ExtractOLM extracts the applied configuration owned by fieldManager from +// oLM. If no managedFields are found in oLM for fieldManager, a +// OLMApplyConfiguration 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. +// oLM must be a unmodified OLM API object that was retrieved from the Kubernetes API. +// ExtractOLM 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 ExtractOLM(oLM *operatorv1alpha1.OLM, fieldManager string) (*OLMApplyConfiguration, error) { + return extractOLM(oLM, fieldManager, "") +} + +// ExtractOLMStatus is the same as ExtractOLM except +// that it extracts the status subresource applied configuration. +// Experimental! +func ExtractOLMStatus(oLM *operatorv1alpha1.OLM, fieldManager string) (*OLMApplyConfiguration, error) { + return extractOLM(oLM, fieldManager, "status") +} + +func extractOLM(oLM *operatorv1alpha1.OLM, fieldManager string, subresource string) (*OLMApplyConfiguration, error) { + b := &OLMApplyConfiguration{} + err := managedfields.ExtractInto(oLM, internal.Parser().Type("com.github.openshift.api.operator.v1alpha1.OLM"), fieldManager, b, subresource) + if err != nil { + return nil, err + } + b.WithName(oLM.Name) + + b.WithKind("OLM") + 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 *OLMApplyConfiguration) WithKind(value string) *OLMApplyConfiguration { + b.TypeMetaApplyConfiguration.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 *OLMApplyConfiguration) WithAPIVersion(value string) *OLMApplyConfiguration { + b.TypeMetaApplyConfiguration.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 *OLMApplyConfiguration) WithName(value string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithGenerateName(value string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithNamespace(value string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithUID(value types.UID) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithResourceVersion(value string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithGeneration(value int64) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithCreationTimestamp(value metav1.Time) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithLabels(entries map[string]string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.ObjectMetaApplyConfiguration.Labels == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Labels = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithAnnotations(entries map[string]string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + if b.ObjectMetaApplyConfiguration.Annotations == nil && len(entries) > 0 { + b.ObjectMetaApplyConfiguration.Annotations = make(map[string]string, len(entries)) + } + for k, v := range entries { + b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + if values[i] == nil { + panic("nil value passed to WithOwnerReferences") + } + b.ObjectMetaApplyConfiguration.OwnerReferences = append(b.ObjectMetaApplyConfiguration.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 *OLMApplyConfiguration) WithFinalizers(values ...string) *OLMApplyConfiguration { + b.ensureObjectMetaApplyConfigurationExists() + for i := range values { + b.ObjectMetaApplyConfiguration.Finalizers = append(b.ObjectMetaApplyConfiguration.Finalizers, values[i]) + } + return b +} + +func (b *OLMApplyConfiguration) 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 *OLMApplyConfiguration) WithSpec(value *OLMSpecApplyConfiguration) *OLMApplyConfiguration { + b.Spec = value + return b +} + +// WithStatus sets the Status 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 Status field is set to the value of the last call. +func (b *OLMApplyConfiguration) WithStatus(value *OLMStatusApplyConfiguration) *OLMApplyConfiguration { + b.Status = value + return b +} + +// GetName retrieves the value of the Name field in the declarative configuration. +func (b *OLMApplyConfiguration) GetName() *string { + b.ensureObjectMetaApplyConfigurationExists() + return b.ObjectMetaApplyConfiguration.Name +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olmspec.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olmspec.go new file mode 100644 index 0000000000..e60f596922 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olmspec.go @@ -0,0 +1,61 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + v1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// OLMSpecApplyConfiguration represents a declarative configuration of the OLMSpec type for use +// with apply. +type OLMSpecApplyConfiguration struct { + v1.OperatorSpecApplyConfiguration `json:",inline"` +} + +// OLMSpecApplyConfiguration constructs a declarative configuration of the OLMSpec type for use with +// apply. +func OLMSpec() *OLMSpecApplyConfiguration { + return &OLMSpecApplyConfiguration{} +} + +// WithManagementState sets the ManagementState 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 ManagementState field is set to the value of the last call. +func (b *OLMSpecApplyConfiguration) WithManagementState(value operatorv1.ManagementState) *OLMSpecApplyConfiguration { + b.OperatorSpecApplyConfiguration.ManagementState = &value + return b +} + +// WithLogLevel sets the LogLevel 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 LogLevel field is set to the value of the last call. +func (b *OLMSpecApplyConfiguration) WithLogLevel(value operatorv1.LogLevel) *OLMSpecApplyConfiguration { + b.OperatorSpecApplyConfiguration.LogLevel = &value + return b +} + +// WithOperatorLogLevel sets the OperatorLogLevel 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 OperatorLogLevel field is set to the value of the last call. +func (b *OLMSpecApplyConfiguration) WithOperatorLogLevel(value operatorv1.LogLevel) *OLMSpecApplyConfiguration { + b.OperatorSpecApplyConfiguration.OperatorLogLevel = &value + return b +} + +// WithUnsupportedConfigOverrides sets the UnsupportedConfigOverrides 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 UnsupportedConfigOverrides field is set to the value of the last call. +func (b *OLMSpecApplyConfiguration) WithUnsupportedConfigOverrides(value runtime.RawExtension) *OLMSpecApplyConfiguration { + b.OperatorSpecApplyConfiguration.UnsupportedConfigOverrides = &value + return b +} + +// WithObservedConfig sets the ObservedConfig 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 ObservedConfig field is set to the value of the last call. +func (b *OLMSpecApplyConfiguration) WithObservedConfig(value runtime.RawExtension) *OLMSpecApplyConfiguration { + b.OperatorSpecApplyConfiguration.ObservedConfig = &value + return b +} diff --git a/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olmstatus.go b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olmstatus.go new file mode 100644 index 0000000000..88f44e1600 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/applyconfigurations/operator/v1alpha1/olmstatus.go @@ -0,0 +1,77 @@ +// Code generated by applyconfiguration-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" +) + +// OLMStatusApplyConfiguration represents a declarative configuration of the OLMStatus type for use +// with apply. +type OLMStatusApplyConfiguration struct { + v1.OperatorStatusApplyConfiguration `json:",inline"` +} + +// OLMStatusApplyConfiguration constructs a declarative configuration of the OLMStatus type for use with +// apply. +func OLMStatus() *OLMStatusApplyConfiguration { + return &OLMStatusApplyConfiguration{} +} + +// WithObservedGeneration sets the ObservedGeneration 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 ObservedGeneration field is set to the value of the last call. +func (b *OLMStatusApplyConfiguration) WithObservedGeneration(value int64) *OLMStatusApplyConfiguration { + b.OperatorStatusApplyConfiguration.ObservedGeneration = &value + return b +} + +// WithConditions adds the given value to the Conditions 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 Conditions field. +func (b *OLMStatusApplyConfiguration) WithConditions(values ...*v1.OperatorConditionApplyConfiguration) *OLMStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithConditions") + } + b.OperatorStatusApplyConfiguration.Conditions = append(b.OperatorStatusApplyConfiguration.Conditions, *values[i]) + } + return b +} + +// WithVersion sets the Version 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 Version field is set to the value of the last call. +func (b *OLMStatusApplyConfiguration) WithVersion(value string) *OLMStatusApplyConfiguration { + b.OperatorStatusApplyConfiguration.Version = &value + return b +} + +// WithReadyReplicas sets the ReadyReplicas 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 ReadyReplicas field is set to the value of the last call. +func (b *OLMStatusApplyConfiguration) WithReadyReplicas(value int32) *OLMStatusApplyConfiguration { + b.OperatorStatusApplyConfiguration.ReadyReplicas = &value + return b +} + +// WithLatestAvailableRevision sets the LatestAvailableRevision 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 LatestAvailableRevision field is set to the value of the last call. +func (b *OLMStatusApplyConfiguration) WithLatestAvailableRevision(value int32) *OLMStatusApplyConfiguration { + b.OperatorStatusApplyConfiguration.LatestAvailableRevision = &value + return b +} + +// WithGenerations adds the given value to the Generations 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 Generations field. +func (b *OLMStatusApplyConfiguration) WithGenerations(values ...*v1.GenerationStatusApplyConfiguration) *OLMStatusApplyConfiguration { + for i := range values { + if values[i] == nil { + panic("nil value passed to WithGenerations") + } + b.OperatorStatusApplyConfiguration.Generations = append(b.OperatorStatusApplyConfiguration.Generations, *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 0000000000..8fa13b722a --- /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 a 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 a 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 0000000000..20e2c729ac --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/clientset.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package versioned + +import ( + fmt "fmt" + http "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. +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/scheme/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/scheme/doc.go new file mode 100644 index 0000000000..14db57a58f --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/scheme/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// This package contains the scheme of the automatically generated clientset. +package scheme diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/scheme/register.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/scheme/register.go new file mode 100644 index 0000000000..04697bcea7 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/scheme/register.go @@ -0,0 +1,42 @@ +// Code generated by client-gen. DO NOT EDIT. + +package scheme + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" + serializer "k8s.io/apimachinery/pkg/runtime/serializer" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" +) + +var Scheme = runtime.NewScheme() +var Codecs = serializer.NewCodecFactory(Scheme) +var ParameterCodec = runtime.NewParameterCodec(Scheme) +var localSchemeBuilder = runtime.SchemeBuilder{ + operatorv1.AddToScheme, + operatorv1alpha1.AddToScheme, +} + +// AddToScheme adds all types of this clientset into the given scheme. This allows composition +// of clientsets, like in: +// +// import ( +// "k8s.io/client-go/kubernetes" +// clientsetscheme "k8s.io/client-go/kubernetes/scheme" +// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme" +// ) +// +// kclientset, _ := kubernetes.NewForConfig(c) +// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme) +// +// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types +// correctly. +var AddToScheme = localSchemeBuilder.AddToScheme + +func init() { + v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"}) + utilruntime.Must(AddToScheme(Scheme)) +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/authentication.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/authentication.go new file mode 100644 index 0000000000..b94b239704 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/authentication.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// AuthenticationsGetter has a method to return a AuthenticationInterface. +// A group's client should implement this interface. +type AuthenticationsGetter interface { + Authentications() AuthenticationInterface +} + +// AuthenticationInterface has methods to work with Authentication resources. +type AuthenticationInterface interface { + Create(ctx context.Context, authentication *operatorv1.Authentication, opts metav1.CreateOptions) (*operatorv1.Authentication, error) + Update(ctx context.Context, authentication *operatorv1.Authentication, opts metav1.UpdateOptions) (*operatorv1.Authentication, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, authentication *operatorv1.Authentication, opts metav1.UpdateOptions) (*operatorv1.Authentication, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.Authentication, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.AuthenticationList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.Authentication, err error) + Apply(ctx context.Context, authentication *applyconfigurationsoperatorv1.AuthenticationApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Authentication, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, authentication *applyconfigurationsoperatorv1.AuthenticationApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Authentication, err error) + AuthenticationExpansion +} + +// authentications implements AuthenticationInterface +type authentications struct { + *gentype.ClientWithListAndApply[*operatorv1.Authentication, *operatorv1.AuthenticationList, *applyconfigurationsoperatorv1.AuthenticationApplyConfiguration] +} + +// newAuthentications returns a Authentications +func newAuthentications(c *OperatorV1Client) *authentications { + return &authentications{ + gentype.NewClientWithListAndApply[*operatorv1.Authentication, *operatorv1.AuthenticationList, *applyconfigurationsoperatorv1.AuthenticationApplyConfiguration]( + "authentications", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.Authentication { return &operatorv1.Authentication{} }, + func() *operatorv1.AuthenticationList { return &operatorv1.AuthenticationList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/cloudcredential.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/cloudcredential.go new file mode 100644 index 0000000000..17f053d459 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/cloudcredential.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// CloudCredentialsGetter has a method to return a CloudCredentialInterface. +// A group's client should implement this interface. +type CloudCredentialsGetter interface { + CloudCredentials() CloudCredentialInterface +} + +// CloudCredentialInterface has methods to work with CloudCredential resources. +type CloudCredentialInterface interface { + Create(ctx context.Context, cloudCredential *operatorv1.CloudCredential, opts metav1.CreateOptions) (*operatorv1.CloudCredential, error) + Update(ctx context.Context, cloudCredential *operatorv1.CloudCredential, opts metav1.UpdateOptions) (*operatorv1.CloudCredential, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, cloudCredential *operatorv1.CloudCredential, opts metav1.UpdateOptions) (*operatorv1.CloudCredential, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.CloudCredential, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.CloudCredentialList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.CloudCredential, err error) + Apply(ctx context.Context, cloudCredential *applyconfigurationsoperatorv1.CloudCredentialApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.CloudCredential, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, cloudCredential *applyconfigurationsoperatorv1.CloudCredentialApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.CloudCredential, err error) + CloudCredentialExpansion +} + +// cloudCredentials implements CloudCredentialInterface +type cloudCredentials struct { + *gentype.ClientWithListAndApply[*operatorv1.CloudCredential, *operatorv1.CloudCredentialList, *applyconfigurationsoperatorv1.CloudCredentialApplyConfiguration] +} + +// newCloudCredentials returns a CloudCredentials +func newCloudCredentials(c *OperatorV1Client) *cloudCredentials { + return &cloudCredentials{ + gentype.NewClientWithListAndApply[*operatorv1.CloudCredential, *operatorv1.CloudCredentialList, *applyconfigurationsoperatorv1.CloudCredentialApplyConfiguration]( + "cloudcredentials", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.CloudCredential { return &operatorv1.CloudCredential{} }, + func() *operatorv1.CloudCredentialList { return &operatorv1.CloudCredentialList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/clustercsidriver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/clustercsidriver.go new file mode 100644 index 0000000000..19d6aec940 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/clustercsidriver.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// ClusterCSIDriversGetter has a method to return a ClusterCSIDriverInterface. +// A group's client should implement this interface. +type ClusterCSIDriversGetter interface { + ClusterCSIDrivers() ClusterCSIDriverInterface +} + +// ClusterCSIDriverInterface has methods to work with ClusterCSIDriver resources. +type ClusterCSIDriverInterface interface { + Create(ctx context.Context, clusterCSIDriver *operatorv1.ClusterCSIDriver, opts metav1.CreateOptions) (*operatorv1.ClusterCSIDriver, error) + Update(ctx context.Context, clusterCSIDriver *operatorv1.ClusterCSIDriver, opts metav1.UpdateOptions) (*operatorv1.ClusterCSIDriver, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, clusterCSIDriver *operatorv1.ClusterCSIDriver, opts metav1.UpdateOptions) (*operatorv1.ClusterCSIDriver, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.ClusterCSIDriver, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.ClusterCSIDriverList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.ClusterCSIDriver, err error) + Apply(ctx context.Context, clusterCSIDriver *applyconfigurationsoperatorv1.ClusterCSIDriverApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ClusterCSIDriver, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, clusterCSIDriver *applyconfigurationsoperatorv1.ClusterCSIDriverApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ClusterCSIDriver, err error) + ClusterCSIDriverExpansion +} + +// clusterCSIDrivers implements ClusterCSIDriverInterface +type clusterCSIDrivers struct { + *gentype.ClientWithListAndApply[*operatorv1.ClusterCSIDriver, *operatorv1.ClusterCSIDriverList, *applyconfigurationsoperatorv1.ClusterCSIDriverApplyConfiguration] +} + +// newClusterCSIDrivers returns a ClusterCSIDrivers +func newClusterCSIDrivers(c *OperatorV1Client) *clusterCSIDrivers { + return &clusterCSIDrivers{ + gentype.NewClientWithListAndApply[*operatorv1.ClusterCSIDriver, *operatorv1.ClusterCSIDriverList, *applyconfigurationsoperatorv1.ClusterCSIDriverApplyConfiguration]( + "clustercsidrivers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.ClusterCSIDriver { return &operatorv1.ClusterCSIDriver{} }, + func() *operatorv1.ClusterCSIDriverList { return &operatorv1.ClusterCSIDriverList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/config.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/config.go new file mode 100644 index 0000000000..71662a63c8 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/config.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// ConfigsGetter has a method to return a ConfigInterface. +// A group's client should implement this interface. +type ConfigsGetter interface { + Configs() ConfigInterface +} + +// ConfigInterface has methods to work with Config resources. +type ConfigInterface interface { + Create(ctx context.Context, config *operatorv1.Config, opts metav1.CreateOptions) (*operatorv1.Config, error) + Update(ctx context.Context, config *operatorv1.Config, opts metav1.UpdateOptions) (*operatorv1.Config, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, config *operatorv1.Config, opts metav1.UpdateOptions) (*operatorv1.Config, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.Config, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.ConfigList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.Config, err error) + Apply(ctx context.Context, config *applyconfigurationsoperatorv1.ConfigApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Config, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, config *applyconfigurationsoperatorv1.ConfigApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Config, err error) + ConfigExpansion +} + +// configs implements ConfigInterface +type configs struct { + *gentype.ClientWithListAndApply[*operatorv1.Config, *operatorv1.ConfigList, *applyconfigurationsoperatorv1.ConfigApplyConfiguration] +} + +// newConfigs returns a Configs +func newConfigs(c *OperatorV1Client) *configs { + return &configs{ + gentype.NewClientWithListAndApply[*operatorv1.Config, *operatorv1.ConfigList, *applyconfigurationsoperatorv1.ConfigApplyConfiguration]( + "configs", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.Config { return &operatorv1.Config{} }, + func() *operatorv1.ConfigList { return &operatorv1.ConfigList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/console.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/console.go new file mode 100644 index 0000000000..1e87763caa --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/console.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// ConsolesGetter has a method to return a ConsoleInterface. +// A group's client should implement this interface. +type ConsolesGetter interface { + Consoles() ConsoleInterface +} + +// ConsoleInterface has methods to work with Console resources. +type ConsoleInterface interface { + Create(ctx context.Context, console *operatorv1.Console, opts metav1.CreateOptions) (*operatorv1.Console, error) + Update(ctx context.Context, console *operatorv1.Console, opts metav1.UpdateOptions) (*operatorv1.Console, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, console *operatorv1.Console, opts metav1.UpdateOptions) (*operatorv1.Console, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.Console, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.ConsoleList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.Console, err error) + Apply(ctx context.Context, console *applyconfigurationsoperatorv1.ConsoleApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Console, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, console *applyconfigurationsoperatorv1.ConsoleApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Console, err error) + ConsoleExpansion +} + +// consoles implements ConsoleInterface +type consoles struct { + *gentype.ClientWithListAndApply[*operatorv1.Console, *operatorv1.ConsoleList, *applyconfigurationsoperatorv1.ConsoleApplyConfiguration] +} + +// newConsoles returns a Consoles +func newConsoles(c *OperatorV1Client) *consoles { + return &consoles{ + gentype.NewClientWithListAndApply[*operatorv1.Console, *operatorv1.ConsoleList, *applyconfigurationsoperatorv1.ConsoleApplyConfiguration]( + "consoles", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.Console { return &operatorv1.Console{} }, + func() *operatorv1.ConsoleList { return &operatorv1.ConsoleList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/csisnapshotcontroller.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/csisnapshotcontroller.go new file mode 100644 index 0000000000..9ce7cf19b3 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/csisnapshotcontroller.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// CSISnapshotControllersGetter has a method to return a CSISnapshotControllerInterface. +// A group's client should implement this interface. +type CSISnapshotControllersGetter interface { + CSISnapshotControllers() CSISnapshotControllerInterface +} + +// CSISnapshotControllerInterface has methods to work with CSISnapshotController resources. +type CSISnapshotControllerInterface interface { + Create(ctx context.Context, cSISnapshotController *operatorv1.CSISnapshotController, opts metav1.CreateOptions) (*operatorv1.CSISnapshotController, error) + Update(ctx context.Context, cSISnapshotController *operatorv1.CSISnapshotController, opts metav1.UpdateOptions) (*operatorv1.CSISnapshotController, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, cSISnapshotController *operatorv1.CSISnapshotController, opts metav1.UpdateOptions) (*operatorv1.CSISnapshotController, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.CSISnapshotController, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.CSISnapshotControllerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.CSISnapshotController, err error) + Apply(ctx context.Context, cSISnapshotController *applyconfigurationsoperatorv1.CSISnapshotControllerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.CSISnapshotController, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, cSISnapshotController *applyconfigurationsoperatorv1.CSISnapshotControllerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.CSISnapshotController, err error) + CSISnapshotControllerExpansion +} + +// cSISnapshotControllers implements CSISnapshotControllerInterface +type cSISnapshotControllers struct { + *gentype.ClientWithListAndApply[*operatorv1.CSISnapshotController, *operatorv1.CSISnapshotControllerList, *applyconfigurationsoperatorv1.CSISnapshotControllerApplyConfiguration] +} + +// newCSISnapshotControllers returns a CSISnapshotControllers +func newCSISnapshotControllers(c *OperatorV1Client) *cSISnapshotControllers { + return &cSISnapshotControllers{ + gentype.NewClientWithListAndApply[*operatorv1.CSISnapshotController, *operatorv1.CSISnapshotControllerList, *applyconfigurationsoperatorv1.CSISnapshotControllerApplyConfiguration]( + "csisnapshotcontrollers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.CSISnapshotController { return &operatorv1.CSISnapshotController{} }, + func() *operatorv1.CSISnapshotControllerList { return &operatorv1.CSISnapshotControllerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/dns.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/dns.go new file mode 100644 index 0000000000..95b89cfbef --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/dns.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// DNSesGetter has a method to return a DNSInterface. +// A group's client should implement this interface. +type DNSesGetter interface { + DNSes() DNSInterface +} + +// DNSInterface has methods to work with DNS resources. +type DNSInterface interface { + Create(ctx context.Context, dNS *operatorv1.DNS, opts metav1.CreateOptions) (*operatorv1.DNS, error) + Update(ctx context.Context, dNS *operatorv1.DNS, opts metav1.UpdateOptions) (*operatorv1.DNS, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, dNS *operatorv1.DNS, opts metav1.UpdateOptions) (*operatorv1.DNS, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.DNS, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.DNSList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.DNS, err error) + Apply(ctx context.Context, dNS *applyconfigurationsoperatorv1.DNSApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.DNS, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, dNS *applyconfigurationsoperatorv1.DNSApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.DNS, err error) + DNSExpansion +} + +// dNSes implements DNSInterface +type dNSes struct { + *gentype.ClientWithListAndApply[*operatorv1.DNS, *operatorv1.DNSList, *applyconfigurationsoperatorv1.DNSApplyConfiguration] +} + +// newDNSes returns a DNSes +func newDNSes(c *OperatorV1Client) *dNSes { + return &dNSes{ + gentype.NewClientWithListAndApply[*operatorv1.DNS, *operatorv1.DNSList, *applyconfigurationsoperatorv1.DNSApplyConfiguration]( + "dnses", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.DNS { return &operatorv1.DNS{} }, + func() *operatorv1.DNSList { return &operatorv1.DNSList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/doc.go new file mode 100644 index 0000000000..225e6b2be3 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v1 diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/etcd.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/etcd.go new file mode 100644 index 0000000000..291445dc82 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/etcd.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// EtcdsGetter has a method to return a EtcdInterface. +// A group's client should implement this interface. +type EtcdsGetter interface { + Etcds() EtcdInterface +} + +// EtcdInterface has methods to work with Etcd resources. +type EtcdInterface interface { + Create(ctx context.Context, etcd *operatorv1.Etcd, opts metav1.CreateOptions) (*operatorv1.Etcd, error) + Update(ctx context.Context, etcd *operatorv1.Etcd, opts metav1.UpdateOptions) (*operatorv1.Etcd, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, etcd *operatorv1.Etcd, opts metav1.UpdateOptions) (*operatorv1.Etcd, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.Etcd, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.EtcdList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.Etcd, err error) + Apply(ctx context.Context, etcd *applyconfigurationsoperatorv1.EtcdApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Etcd, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, etcd *applyconfigurationsoperatorv1.EtcdApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Etcd, err error) + EtcdExpansion +} + +// etcds implements EtcdInterface +type etcds struct { + *gentype.ClientWithListAndApply[*operatorv1.Etcd, *operatorv1.EtcdList, *applyconfigurationsoperatorv1.EtcdApplyConfiguration] +} + +// newEtcds returns a Etcds +func newEtcds(c *OperatorV1Client) *etcds { + return &etcds{ + gentype.NewClientWithListAndApply[*operatorv1.Etcd, *operatorv1.EtcdList, *applyconfigurationsoperatorv1.EtcdApplyConfiguration]( + "etcds", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.Etcd { return &operatorv1.Etcd{} }, + func() *operatorv1.EtcdList { return &operatorv1.EtcdList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/generated_expansion.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/generated_expansion.go new file mode 100644 index 0000000000..67d774a2a7 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/generated_expansion.go @@ -0,0 +1,49 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +type AuthenticationExpansion interface{} + +type CSISnapshotControllerExpansion interface{} + +type CloudCredentialExpansion interface{} + +type ClusterCSIDriverExpansion interface{} + +type ConfigExpansion interface{} + +type ConsoleExpansion interface{} + +type DNSExpansion interface{} + +type EtcdExpansion interface{} + +type IngressControllerExpansion interface{} + +type InsightsOperatorExpansion interface{} + +type KubeAPIServerExpansion interface{} + +type KubeControllerManagerExpansion interface{} + +type KubeSchedulerExpansion interface{} + +type KubeStorageVersionMigratorExpansion interface{} + +type MachineConfigurationExpansion interface{} + +type NetworkExpansion interface{} + +type OLMExpansion interface{} + +type OpenShiftAPIServerExpansion interface{} + +type OpenShiftControllerManagerExpansion interface{} + +type ServiceCAExpansion interface{} + +type ServiceCatalogAPIServerExpansion interface{} + +type ServiceCatalogControllerManagerExpansion interface{} + +type StorageExpansion interface{} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/ingresscontroller.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/ingresscontroller.go new file mode 100644 index 0000000000..601562e1ee --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/ingresscontroller.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// IngressControllersGetter has a method to return a IngressControllerInterface. +// A group's client should implement this interface. +type IngressControllersGetter interface { + IngressControllers(namespace string) IngressControllerInterface +} + +// IngressControllerInterface has methods to work with IngressController resources. +type IngressControllerInterface interface { + Create(ctx context.Context, ingressController *operatorv1.IngressController, opts metav1.CreateOptions) (*operatorv1.IngressController, error) + Update(ctx context.Context, ingressController *operatorv1.IngressController, opts metav1.UpdateOptions) (*operatorv1.IngressController, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, ingressController *operatorv1.IngressController, opts metav1.UpdateOptions) (*operatorv1.IngressController, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.IngressController, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.IngressControllerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.IngressController, err error) + Apply(ctx context.Context, ingressController *applyconfigurationsoperatorv1.IngressControllerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.IngressController, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, ingressController *applyconfigurationsoperatorv1.IngressControllerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.IngressController, err error) + IngressControllerExpansion +} + +// ingressControllers implements IngressControllerInterface +type ingressControllers struct { + *gentype.ClientWithListAndApply[*operatorv1.IngressController, *operatorv1.IngressControllerList, *applyconfigurationsoperatorv1.IngressControllerApplyConfiguration] +} + +// newIngressControllers returns a IngressControllers +func newIngressControllers(c *OperatorV1Client, namespace string) *ingressControllers { + return &ingressControllers{ + gentype.NewClientWithListAndApply[*operatorv1.IngressController, *operatorv1.IngressControllerList, *applyconfigurationsoperatorv1.IngressControllerApplyConfiguration]( + "ingresscontrollers", + c.RESTClient(), + scheme.ParameterCodec, + namespace, + func() *operatorv1.IngressController { return &operatorv1.IngressController{} }, + func() *operatorv1.IngressControllerList { return &operatorv1.IngressControllerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/insightsoperator.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/insightsoperator.go new file mode 100644 index 0000000000..6e541dba87 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/insightsoperator.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// InsightsOperatorsGetter has a method to return a InsightsOperatorInterface. +// A group's client should implement this interface. +type InsightsOperatorsGetter interface { + InsightsOperators() InsightsOperatorInterface +} + +// InsightsOperatorInterface has methods to work with InsightsOperator resources. +type InsightsOperatorInterface interface { + Create(ctx context.Context, insightsOperator *operatorv1.InsightsOperator, opts metav1.CreateOptions) (*operatorv1.InsightsOperator, error) + Update(ctx context.Context, insightsOperator *operatorv1.InsightsOperator, opts metav1.UpdateOptions) (*operatorv1.InsightsOperator, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, insightsOperator *operatorv1.InsightsOperator, opts metav1.UpdateOptions) (*operatorv1.InsightsOperator, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.InsightsOperator, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.InsightsOperatorList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.InsightsOperator, err error) + Apply(ctx context.Context, insightsOperator *applyconfigurationsoperatorv1.InsightsOperatorApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.InsightsOperator, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, insightsOperator *applyconfigurationsoperatorv1.InsightsOperatorApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.InsightsOperator, err error) + InsightsOperatorExpansion +} + +// insightsOperators implements InsightsOperatorInterface +type insightsOperators struct { + *gentype.ClientWithListAndApply[*operatorv1.InsightsOperator, *operatorv1.InsightsOperatorList, *applyconfigurationsoperatorv1.InsightsOperatorApplyConfiguration] +} + +// newInsightsOperators returns a InsightsOperators +func newInsightsOperators(c *OperatorV1Client) *insightsOperators { + return &insightsOperators{ + gentype.NewClientWithListAndApply[*operatorv1.InsightsOperator, *operatorv1.InsightsOperatorList, *applyconfigurationsoperatorv1.InsightsOperatorApplyConfiguration]( + "insightsoperators", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.InsightsOperator { return &operatorv1.InsightsOperator{} }, + func() *operatorv1.InsightsOperatorList { return &operatorv1.InsightsOperatorList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubeapiserver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubeapiserver.go new file mode 100644 index 0000000000..9bfb6ce749 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubeapiserver.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// KubeAPIServersGetter has a method to return a KubeAPIServerInterface. +// A group's client should implement this interface. +type KubeAPIServersGetter interface { + KubeAPIServers() KubeAPIServerInterface +} + +// KubeAPIServerInterface has methods to work with KubeAPIServer resources. +type KubeAPIServerInterface interface { + Create(ctx context.Context, kubeAPIServer *operatorv1.KubeAPIServer, opts metav1.CreateOptions) (*operatorv1.KubeAPIServer, error) + Update(ctx context.Context, kubeAPIServer *operatorv1.KubeAPIServer, opts metav1.UpdateOptions) (*operatorv1.KubeAPIServer, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, kubeAPIServer *operatorv1.KubeAPIServer, opts metav1.UpdateOptions) (*operatorv1.KubeAPIServer, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.KubeAPIServer, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.KubeAPIServerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.KubeAPIServer, err error) + Apply(ctx context.Context, kubeAPIServer *applyconfigurationsoperatorv1.KubeAPIServerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeAPIServer, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, kubeAPIServer *applyconfigurationsoperatorv1.KubeAPIServerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeAPIServer, err error) + KubeAPIServerExpansion +} + +// kubeAPIServers implements KubeAPIServerInterface +type kubeAPIServers struct { + *gentype.ClientWithListAndApply[*operatorv1.KubeAPIServer, *operatorv1.KubeAPIServerList, *applyconfigurationsoperatorv1.KubeAPIServerApplyConfiguration] +} + +// newKubeAPIServers returns a KubeAPIServers +func newKubeAPIServers(c *OperatorV1Client) *kubeAPIServers { + return &kubeAPIServers{ + gentype.NewClientWithListAndApply[*operatorv1.KubeAPIServer, *operatorv1.KubeAPIServerList, *applyconfigurationsoperatorv1.KubeAPIServerApplyConfiguration]( + "kubeapiservers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.KubeAPIServer { return &operatorv1.KubeAPIServer{} }, + func() *operatorv1.KubeAPIServerList { return &operatorv1.KubeAPIServerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubecontrollermanager.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubecontrollermanager.go new file mode 100644 index 0000000000..4e5bc0181c --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubecontrollermanager.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// KubeControllerManagersGetter has a method to return a KubeControllerManagerInterface. +// A group's client should implement this interface. +type KubeControllerManagersGetter interface { + KubeControllerManagers() KubeControllerManagerInterface +} + +// KubeControllerManagerInterface has methods to work with KubeControllerManager resources. +type KubeControllerManagerInterface interface { + Create(ctx context.Context, kubeControllerManager *operatorv1.KubeControllerManager, opts metav1.CreateOptions) (*operatorv1.KubeControllerManager, error) + Update(ctx context.Context, kubeControllerManager *operatorv1.KubeControllerManager, opts metav1.UpdateOptions) (*operatorv1.KubeControllerManager, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, kubeControllerManager *operatorv1.KubeControllerManager, opts metav1.UpdateOptions) (*operatorv1.KubeControllerManager, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.KubeControllerManager, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.KubeControllerManagerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.KubeControllerManager, err error) + Apply(ctx context.Context, kubeControllerManager *applyconfigurationsoperatorv1.KubeControllerManagerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeControllerManager, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, kubeControllerManager *applyconfigurationsoperatorv1.KubeControllerManagerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeControllerManager, err error) + KubeControllerManagerExpansion +} + +// kubeControllerManagers implements KubeControllerManagerInterface +type kubeControllerManagers struct { + *gentype.ClientWithListAndApply[*operatorv1.KubeControllerManager, *operatorv1.KubeControllerManagerList, *applyconfigurationsoperatorv1.KubeControllerManagerApplyConfiguration] +} + +// newKubeControllerManagers returns a KubeControllerManagers +func newKubeControllerManagers(c *OperatorV1Client) *kubeControllerManagers { + return &kubeControllerManagers{ + gentype.NewClientWithListAndApply[*operatorv1.KubeControllerManager, *operatorv1.KubeControllerManagerList, *applyconfigurationsoperatorv1.KubeControllerManagerApplyConfiguration]( + "kubecontrollermanagers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.KubeControllerManager { return &operatorv1.KubeControllerManager{} }, + func() *operatorv1.KubeControllerManagerList { return &operatorv1.KubeControllerManagerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubescheduler.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubescheduler.go new file mode 100644 index 0000000000..fe5bde8ff4 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubescheduler.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// KubeSchedulersGetter has a method to return a KubeSchedulerInterface. +// A group's client should implement this interface. +type KubeSchedulersGetter interface { + KubeSchedulers() KubeSchedulerInterface +} + +// KubeSchedulerInterface has methods to work with KubeScheduler resources. +type KubeSchedulerInterface interface { + Create(ctx context.Context, kubeScheduler *operatorv1.KubeScheduler, opts metav1.CreateOptions) (*operatorv1.KubeScheduler, error) + Update(ctx context.Context, kubeScheduler *operatorv1.KubeScheduler, opts metav1.UpdateOptions) (*operatorv1.KubeScheduler, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, kubeScheduler *operatorv1.KubeScheduler, opts metav1.UpdateOptions) (*operatorv1.KubeScheduler, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.KubeScheduler, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.KubeSchedulerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.KubeScheduler, err error) + Apply(ctx context.Context, kubeScheduler *applyconfigurationsoperatorv1.KubeSchedulerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeScheduler, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, kubeScheduler *applyconfigurationsoperatorv1.KubeSchedulerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeScheduler, err error) + KubeSchedulerExpansion +} + +// kubeSchedulers implements KubeSchedulerInterface +type kubeSchedulers struct { + *gentype.ClientWithListAndApply[*operatorv1.KubeScheduler, *operatorv1.KubeSchedulerList, *applyconfigurationsoperatorv1.KubeSchedulerApplyConfiguration] +} + +// newKubeSchedulers returns a KubeSchedulers +func newKubeSchedulers(c *OperatorV1Client) *kubeSchedulers { + return &kubeSchedulers{ + gentype.NewClientWithListAndApply[*operatorv1.KubeScheduler, *operatorv1.KubeSchedulerList, *applyconfigurationsoperatorv1.KubeSchedulerApplyConfiguration]( + "kubeschedulers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.KubeScheduler { return &operatorv1.KubeScheduler{} }, + func() *operatorv1.KubeSchedulerList { return &operatorv1.KubeSchedulerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubestorageversionmigrator.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubestorageversionmigrator.go new file mode 100644 index 0000000000..b15f2b9022 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/kubestorageversionmigrator.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// KubeStorageVersionMigratorsGetter has a method to return a KubeStorageVersionMigratorInterface. +// A group's client should implement this interface. +type KubeStorageVersionMigratorsGetter interface { + KubeStorageVersionMigrators() KubeStorageVersionMigratorInterface +} + +// KubeStorageVersionMigratorInterface has methods to work with KubeStorageVersionMigrator resources. +type KubeStorageVersionMigratorInterface interface { + Create(ctx context.Context, kubeStorageVersionMigrator *operatorv1.KubeStorageVersionMigrator, opts metav1.CreateOptions) (*operatorv1.KubeStorageVersionMigrator, error) + Update(ctx context.Context, kubeStorageVersionMigrator *operatorv1.KubeStorageVersionMigrator, opts metav1.UpdateOptions) (*operatorv1.KubeStorageVersionMigrator, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, kubeStorageVersionMigrator *operatorv1.KubeStorageVersionMigrator, opts metav1.UpdateOptions) (*operatorv1.KubeStorageVersionMigrator, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.KubeStorageVersionMigrator, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.KubeStorageVersionMigratorList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.KubeStorageVersionMigrator, err error) + Apply(ctx context.Context, kubeStorageVersionMigrator *applyconfigurationsoperatorv1.KubeStorageVersionMigratorApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeStorageVersionMigrator, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, kubeStorageVersionMigrator *applyconfigurationsoperatorv1.KubeStorageVersionMigratorApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.KubeStorageVersionMigrator, err error) + KubeStorageVersionMigratorExpansion +} + +// kubeStorageVersionMigrators implements KubeStorageVersionMigratorInterface +type kubeStorageVersionMigrators struct { + *gentype.ClientWithListAndApply[*operatorv1.KubeStorageVersionMigrator, *operatorv1.KubeStorageVersionMigratorList, *applyconfigurationsoperatorv1.KubeStorageVersionMigratorApplyConfiguration] +} + +// newKubeStorageVersionMigrators returns a KubeStorageVersionMigrators +func newKubeStorageVersionMigrators(c *OperatorV1Client) *kubeStorageVersionMigrators { + return &kubeStorageVersionMigrators{ + gentype.NewClientWithListAndApply[*operatorv1.KubeStorageVersionMigrator, *operatorv1.KubeStorageVersionMigratorList, *applyconfigurationsoperatorv1.KubeStorageVersionMigratorApplyConfiguration]( + "kubestorageversionmigrators", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.KubeStorageVersionMigrator { return &operatorv1.KubeStorageVersionMigrator{} }, + func() *operatorv1.KubeStorageVersionMigratorList { return &operatorv1.KubeStorageVersionMigratorList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/machineconfiguration.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/machineconfiguration.go new file mode 100644 index 0000000000..813bc2f2e7 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/machineconfiguration.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// MachineConfigurationsGetter has a method to return a MachineConfigurationInterface. +// A group's client should implement this interface. +type MachineConfigurationsGetter interface { + MachineConfigurations() MachineConfigurationInterface +} + +// MachineConfigurationInterface has methods to work with MachineConfiguration resources. +type MachineConfigurationInterface interface { + Create(ctx context.Context, machineConfiguration *operatorv1.MachineConfiguration, opts metav1.CreateOptions) (*operatorv1.MachineConfiguration, error) + Update(ctx context.Context, machineConfiguration *operatorv1.MachineConfiguration, opts metav1.UpdateOptions) (*operatorv1.MachineConfiguration, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, machineConfiguration *operatorv1.MachineConfiguration, opts metav1.UpdateOptions) (*operatorv1.MachineConfiguration, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.MachineConfiguration, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.MachineConfigurationList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.MachineConfiguration, err error) + Apply(ctx context.Context, machineConfiguration *applyconfigurationsoperatorv1.MachineConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.MachineConfiguration, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, machineConfiguration *applyconfigurationsoperatorv1.MachineConfigurationApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.MachineConfiguration, err error) + MachineConfigurationExpansion +} + +// machineConfigurations implements MachineConfigurationInterface +type machineConfigurations struct { + *gentype.ClientWithListAndApply[*operatorv1.MachineConfiguration, *operatorv1.MachineConfigurationList, *applyconfigurationsoperatorv1.MachineConfigurationApplyConfiguration] +} + +// newMachineConfigurations returns a MachineConfigurations +func newMachineConfigurations(c *OperatorV1Client) *machineConfigurations { + return &machineConfigurations{ + gentype.NewClientWithListAndApply[*operatorv1.MachineConfiguration, *operatorv1.MachineConfigurationList, *applyconfigurationsoperatorv1.MachineConfigurationApplyConfiguration]( + "machineconfigurations", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.MachineConfiguration { return &operatorv1.MachineConfiguration{} }, + func() *operatorv1.MachineConfigurationList { return &operatorv1.MachineConfigurationList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/network.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/network.go new file mode 100644 index 0000000000..d4777b0241 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/network.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// NetworksGetter has a method to return a NetworkInterface. +// A group's client should implement this interface. +type NetworksGetter interface { + Networks() NetworkInterface +} + +// NetworkInterface has methods to work with Network resources. +type NetworkInterface interface { + Create(ctx context.Context, network *operatorv1.Network, opts metav1.CreateOptions) (*operatorv1.Network, error) + Update(ctx context.Context, network *operatorv1.Network, opts metav1.UpdateOptions) (*operatorv1.Network, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, network *operatorv1.Network, opts metav1.UpdateOptions) (*operatorv1.Network, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.Network, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.NetworkList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.Network, err error) + Apply(ctx context.Context, network *applyconfigurationsoperatorv1.NetworkApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Network, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, network *applyconfigurationsoperatorv1.NetworkApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Network, err error) + NetworkExpansion +} + +// networks implements NetworkInterface +type networks struct { + *gentype.ClientWithListAndApply[*operatorv1.Network, *operatorv1.NetworkList, *applyconfigurationsoperatorv1.NetworkApplyConfiguration] +} + +// newNetworks returns a Networks +func newNetworks(c *OperatorV1Client) *networks { + return &networks{ + gentype.NewClientWithListAndApply[*operatorv1.Network, *operatorv1.NetworkList, *applyconfigurationsoperatorv1.NetworkApplyConfiguration]( + "networks", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.Network { return &operatorv1.Network{} }, + func() *operatorv1.NetworkList { return &operatorv1.NetworkList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/olm.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/olm.go new file mode 100644 index 0000000000..866906e684 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/olm.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// OLMsGetter has a method to return a OLMInterface. +// A group's client should implement this interface. +type OLMsGetter interface { + OLMs() OLMInterface +} + +// OLMInterface has methods to work with OLM resources. +type OLMInterface interface { + Create(ctx context.Context, oLM *operatorv1.OLM, opts metav1.CreateOptions) (*operatorv1.OLM, error) + Update(ctx context.Context, oLM *operatorv1.OLM, opts metav1.UpdateOptions) (*operatorv1.OLM, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, oLM *operatorv1.OLM, opts metav1.UpdateOptions) (*operatorv1.OLM, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.OLM, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.OLMList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.OLM, err error) + Apply(ctx context.Context, oLM *applyconfigurationsoperatorv1.OLMApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.OLM, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, oLM *applyconfigurationsoperatorv1.OLMApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.OLM, err error) + OLMExpansion +} + +// oLMs implements OLMInterface +type oLMs struct { + *gentype.ClientWithListAndApply[*operatorv1.OLM, *operatorv1.OLMList, *applyconfigurationsoperatorv1.OLMApplyConfiguration] +} + +// newOLMs returns a OLMs +func newOLMs(c *OperatorV1Client) *oLMs { + return &oLMs{ + gentype.NewClientWithListAndApply[*operatorv1.OLM, *operatorv1.OLMList, *applyconfigurationsoperatorv1.OLMApplyConfiguration]( + "olms", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.OLM { return &operatorv1.OLM{} }, + func() *operatorv1.OLMList { return &operatorv1.OLMList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/openshiftapiserver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/openshiftapiserver.go new file mode 100644 index 0000000000..942c8fc6f1 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/openshiftapiserver.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// OpenShiftAPIServersGetter has a method to return a OpenShiftAPIServerInterface. +// A group's client should implement this interface. +type OpenShiftAPIServersGetter interface { + OpenShiftAPIServers() OpenShiftAPIServerInterface +} + +// OpenShiftAPIServerInterface has methods to work with OpenShiftAPIServer resources. +type OpenShiftAPIServerInterface interface { + Create(ctx context.Context, openShiftAPIServer *operatorv1.OpenShiftAPIServer, opts metav1.CreateOptions) (*operatorv1.OpenShiftAPIServer, error) + Update(ctx context.Context, openShiftAPIServer *operatorv1.OpenShiftAPIServer, opts metav1.UpdateOptions) (*operatorv1.OpenShiftAPIServer, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, openShiftAPIServer *operatorv1.OpenShiftAPIServer, opts metav1.UpdateOptions) (*operatorv1.OpenShiftAPIServer, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.OpenShiftAPIServer, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.OpenShiftAPIServerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.OpenShiftAPIServer, err error) + Apply(ctx context.Context, openShiftAPIServer *applyconfigurationsoperatorv1.OpenShiftAPIServerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.OpenShiftAPIServer, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, openShiftAPIServer *applyconfigurationsoperatorv1.OpenShiftAPIServerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.OpenShiftAPIServer, err error) + OpenShiftAPIServerExpansion +} + +// openShiftAPIServers implements OpenShiftAPIServerInterface +type openShiftAPIServers struct { + *gentype.ClientWithListAndApply[*operatorv1.OpenShiftAPIServer, *operatorv1.OpenShiftAPIServerList, *applyconfigurationsoperatorv1.OpenShiftAPIServerApplyConfiguration] +} + +// newOpenShiftAPIServers returns a OpenShiftAPIServers +func newOpenShiftAPIServers(c *OperatorV1Client) *openShiftAPIServers { + return &openShiftAPIServers{ + gentype.NewClientWithListAndApply[*operatorv1.OpenShiftAPIServer, *operatorv1.OpenShiftAPIServerList, *applyconfigurationsoperatorv1.OpenShiftAPIServerApplyConfiguration]( + "openshiftapiservers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.OpenShiftAPIServer { return &operatorv1.OpenShiftAPIServer{} }, + func() *operatorv1.OpenShiftAPIServerList { return &operatorv1.OpenShiftAPIServerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/openshiftcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/openshiftcontrollermanager.go new file mode 100644 index 0000000000..0f729ad336 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/openshiftcontrollermanager.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// OpenShiftControllerManagersGetter has a method to return a OpenShiftControllerManagerInterface. +// A group's client should implement this interface. +type OpenShiftControllerManagersGetter interface { + OpenShiftControllerManagers() OpenShiftControllerManagerInterface +} + +// OpenShiftControllerManagerInterface has methods to work with OpenShiftControllerManager resources. +type OpenShiftControllerManagerInterface interface { + Create(ctx context.Context, openShiftControllerManager *operatorv1.OpenShiftControllerManager, opts metav1.CreateOptions) (*operatorv1.OpenShiftControllerManager, error) + Update(ctx context.Context, openShiftControllerManager *operatorv1.OpenShiftControllerManager, opts metav1.UpdateOptions) (*operatorv1.OpenShiftControllerManager, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, openShiftControllerManager *operatorv1.OpenShiftControllerManager, opts metav1.UpdateOptions) (*operatorv1.OpenShiftControllerManager, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.OpenShiftControllerManager, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.OpenShiftControllerManagerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.OpenShiftControllerManager, err error) + Apply(ctx context.Context, openShiftControllerManager *applyconfigurationsoperatorv1.OpenShiftControllerManagerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.OpenShiftControllerManager, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, openShiftControllerManager *applyconfigurationsoperatorv1.OpenShiftControllerManagerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.OpenShiftControllerManager, err error) + OpenShiftControllerManagerExpansion +} + +// openShiftControllerManagers implements OpenShiftControllerManagerInterface +type openShiftControllerManagers struct { + *gentype.ClientWithListAndApply[*operatorv1.OpenShiftControllerManager, *operatorv1.OpenShiftControllerManagerList, *applyconfigurationsoperatorv1.OpenShiftControllerManagerApplyConfiguration] +} + +// newOpenShiftControllerManagers returns a OpenShiftControllerManagers +func newOpenShiftControllerManagers(c *OperatorV1Client) *openShiftControllerManagers { + return &openShiftControllerManagers{ + gentype.NewClientWithListAndApply[*operatorv1.OpenShiftControllerManager, *operatorv1.OpenShiftControllerManagerList, *applyconfigurationsoperatorv1.OpenShiftControllerManagerApplyConfiguration]( + "openshiftcontrollermanagers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.OpenShiftControllerManager { return &operatorv1.OpenShiftControllerManager{} }, + func() *operatorv1.OpenShiftControllerManagerList { return &operatorv1.OpenShiftControllerManagerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/operator_client.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/operator_client.go new file mode 100644 index 0000000000..0b52301c53 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/operator_client.go @@ -0,0 +1,201 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + http "net/http" + + operatorv1 "github.com/openshift/api/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + rest "k8s.io/client-go/rest" +) + +type OperatorV1Interface interface { + RESTClient() rest.Interface + AuthenticationsGetter + CSISnapshotControllersGetter + CloudCredentialsGetter + ClusterCSIDriversGetter + ConfigsGetter + ConsolesGetter + DNSesGetter + EtcdsGetter + IngressControllersGetter + InsightsOperatorsGetter + KubeAPIServersGetter + KubeControllerManagersGetter + KubeSchedulersGetter + KubeStorageVersionMigratorsGetter + MachineConfigurationsGetter + NetworksGetter + OLMsGetter + OpenShiftAPIServersGetter + OpenShiftControllerManagersGetter + ServiceCAsGetter + ServiceCatalogAPIServersGetter + ServiceCatalogControllerManagersGetter + StoragesGetter +} + +// OperatorV1Client is used to interact with features provided by the operator.openshift.io group. +type OperatorV1Client struct { + restClient rest.Interface +} + +func (c *OperatorV1Client) Authentications() AuthenticationInterface { + return newAuthentications(c) +} + +func (c *OperatorV1Client) CSISnapshotControllers() CSISnapshotControllerInterface { + return newCSISnapshotControllers(c) +} + +func (c *OperatorV1Client) CloudCredentials() CloudCredentialInterface { + return newCloudCredentials(c) +} + +func (c *OperatorV1Client) ClusterCSIDrivers() ClusterCSIDriverInterface { + return newClusterCSIDrivers(c) +} + +func (c *OperatorV1Client) Configs() ConfigInterface { + return newConfigs(c) +} + +func (c *OperatorV1Client) Consoles() ConsoleInterface { + return newConsoles(c) +} + +func (c *OperatorV1Client) DNSes() DNSInterface { + return newDNSes(c) +} + +func (c *OperatorV1Client) Etcds() EtcdInterface { + return newEtcds(c) +} + +func (c *OperatorV1Client) IngressControllers(namespace string) IngressControllerInterface { + return newIngressControllers(c, namespace) +} + +func (c *OperatorV1Client) InsightsOperators() InsightsOperatorInterface { + return newInsightsOperators(c) +} + +func (c *OperatorV1Client) KubeAPIServers() KubeAPIServerInterface { + return newKubeAPIServers(c) +} + +func (c *OperatorV1Client) KubeControllerManagers() KubeControllerManagerInterface { + return newKubeControllerManagers(c) +} + +func (c *OperatorV1Client) KubeSchedulers() KubeSchedulerInterface { + return newKubeSchedulers(c) +} + +func (c *OperatorV1Client) KubeStorageVersionMigrators() KubeStorageVersionMigratorInterface { + return newKubeStorageVersionMigrators(c) +} + +func (c *OperatorV1Client) MachineConfigurations() MachineConfigurationInterface { + return newMachineConfigurations(c) +} + +func (c *OperatorV1Client) Networks() NetworkInterface { + return newNetworks(c) +} + +func (c *OperatorV1Client) OLMs() OLMInterface { + return newOLMs(c) +} + +func (c *OperatorV1Client) OpenShiftAPIServers() OpenShiftAPIServerInterface { + return newOpenShiftAPIServers(c) +} + +func (c *OperatorV1Client) OpenShiftControllerManagers() OpenShiftControllerManagerInterface { + return newOpenShiftControllerManagers(c) +} + +func (c *OperatorV1Client) ServiceCAs() ServiceCAInterface { + return newServiceCAs(c) +} + +func (c *OperatorV1Client) ServiceCatalogAPIServers() ServiceCatalogAPIServerInterface { + return newServiceCatalogAPIServers(c) +} + +func (c *OperatorV1Client) ServiceCatalogControllerManagers() ServiceCatalogControllerManagerInterface { + return newServiceCatalogControllerManagers(c) +} + +func (c *OperatorV1Client) Storages() StorageInterface { + return newStorages(c) +} + +// NewForConfig creates a new OperatorV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*OperatorV1Client, 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 OperatorV1Client 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) (*OperatorV1Client, 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 &OperatorV1Client{client}, nil +} + +// NewForConfigOrDie creates a new OperatorV1Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *OperatorV1Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new OperatorV1Client for the given RESTClient. +func New(c rest.Interface) *OperatorV1Client { + return &OperatorV1Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := operatorv1.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = rest.CodecFactoryForGeneratedClient(scheme.Scheme, 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 *OperatorV1Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/serviceca.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/serviceca.go new file mode 100644 index 0000000000..1827f8793f --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/serviceca.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// ServiceCAsGetter has a method to return a ServiceCAInterface. +// A group's client should implement this interface. +type ServiceCAsGetter interface { + ServiceCAs() ServiceCAInterface +} + +// ServiceCAInterface has methods to work with ServiceCA resources. +type ServiceCAInterface interface { + Create(ctx context.Context, serviceCA *operatorv1.ServiceCA, opts metav1.CreateOptions) (*operatorv1.ServiceCA, error) + Update(ctx context.Context, serviceCA *operatorv1.ServiceCA, opts metav1.UpdateOptions) (*operatorv1.ServiceCA, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, serviceCA *operatorv1.ServiceCA, opts metav1.UpdateOptions) (*operatorv1.ServiceCA, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.ServiceCA, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.ServiceCAList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.ServiceCA, err error) + Apply(ctx context.Context, serviceCA *applyconfigurationsoperatorv1.ServiceCAApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ServiceCA, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, serviceCA *applyconfigurationsoperatorv1.ServiceCAApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ServiceCA, err error) + ServiceCAExpansion +} + +// serviceCAs implements ServiceCAInterface +type serviceCAs struct { + *gentype.ClientWithListAndApply[*operatorv1.ServiceCA, *operatorv1.ServiceCAList, *applyconfigurationsoperatorv1.ServiceCAApplyConfiguration] +} + +// newServiceCAs returns a ServiceCAs +func newServiceCAs(c *OperatorV1Client) *serviceCAs { + return &serviceCAs{ + gentype.NewClientWithListAndApply[*operatorv1.ServiceCA, *operatorv1.ServiceCAList, *applyconfigurationsoperatorv1.ServiceCAApplyConfiguration]( + "servicecas", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.ServiceCA { return &operatorv1.ServiceCA{} }, + func() *operatorv1.ServiceCAList { return &operatorv1.ServiceCAList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/servicecatalogapiserver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/servicecatalogapiserver.go new file mode 100644 index 0000000000..9c31f0a3eb --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/servicecatalogapiserver.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// ServiceCatalogAPIServersGetter has a method to return a ServiceCatalogAPIServerInterface. +// A group's client should implement this interface. +type ServiceCatalogAPIServersGetter interface { + ServiceCatalogAPIServers() ServiceCatalogAPIServerInterface +} + +// ServiceCatalogAPIServerInterface has methods to work with ServiceCatalogAPIServer resources. +type ServiceCatalogAPIServerInterface interface { + Create(ctx context.Context, serviceCatalogAPIServer *operatorv1.ServiceCatalogAPIServer, opts metav1.CreateOptions) (*operatorv1.ServiceCatalogAPIServer, error) + Update(ctx context.Context, serviceCatalogAPIServer *operatorv1.ServiceCatalogAPIServer, opts metav1.UpdateOptions) (*operatorv1.ServiceCatalogAPIServer, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, serviceCatalogAPIServer *operatorv1.ServiceCatalogAPIServer, opts metav1.UpdateOptions) (*operatorv1.ServiceCatalogAPIServer, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.ServiceCatalogAPIServer, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.ServiceCatalogAPIServerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.ServiceCatalogAPIServer, err error) + Apply(ctx context.Context, serviceCatalogAPIServer *applyconfigurationsoperatorv1.ServiceCatalogAPIServerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ServiceCatalogAPIServer, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, serviceCatalogAPIServer *applyconfigurationsoperatorv1.ServiceCatalogAPIServerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ServiceCatalogAPIServer, err error) + ServiceCatalogAPIServerExpansion +} + +// serviceCatalogAPIServers implements ServiceCatalogAPIServerInterface +type serviceCatalogAPIServers struct { + *gentype.ClientWithListAndApply[*operatorv1.ServiceCatalogAPIServer, *operatorv1.ServiceCatalogAPIServerList, *applyconfigurationsoperatorv1.ServiceCatalogAPIServerApplyConfiguration] +} + +// newServiceCatalogAPIServers returns a ServiceCatalogAPIServers +func newServiceCatalogAPIServers(c *OperatorV1Client) *serviceCatalogAPIServers { + return &serviceCatalogAPIServers{ + gentype.NewClientWithListAndApply[*operatorv1.ServiceCatalogAPIServer, *operatorv1.ServiceCatalogAPIServerList, *applyconfigurationsoperatorv1.ServiceCatalogAPIServerApplyConfiguration]( + "servicecatalogapiservers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.ServiceCatalogAPIServer { return &operatorv1.ServiceCatalogAPIServer{} }, + func() *operatorv1.ServiceCatalogAPIServerList { return &operatorv1.ServiceCatalogAPIServerList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/servicecatalogcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/servicecatalogcontrollermanager.go new file mode 100644 index 0000000000..5e5e3f2083 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/servicecatalogcontrollermanager.go @@ -0,0 +1,62 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// ServiceCatalogControllerManagersGetter has a method to return a ServiceCatalogControllerManagerInterface. +// A group's client should implement this interface. +type ServiceCatalogControllerManagersGetter interface { + ServiceCatalogControllerManagers() ServiceCatalogControllerManagerInterface +} + +// ServiceCatalogControllerManagerInterface has methods to work with ServiceCatalogControllerManager resources. +type ServiceCatalogControllerManagerInterface interface { + Create(ctx context.Context, serviceCatalogControllerManager *operatorv1.ServiceCatalogControllerManager, opts metav1.CreateOptions) (*operatorv1.ServiceCatalogControllerManager, error) + Update(ctx context.Context, serviceCatalogControllerManager *operatorv1.ServiceCatalogControllerManager, opts metav1.UpdateOptions) (*operatorv1.ServiceCatalogControllerManager, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, serviceCatalogControllerManager *operatorv1.ServiceCatalogControllerManager, opts metav1.UpdateOptions) (*operatorv1.ServiceCatalogControllerManager, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.ServiceCatalogControllerManager, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.ServiceCatalogControllerManagerList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.ServiceCatalogControllerManager, err error) + Apply(ctx context.Context, serviceCatalogControllerManager *applyconfigurationsoperatorv1.ServiceCatalogControllerManagerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ServiceCatalogControllerManager, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, serviceCatalogControllerManager *applyconfigurationsoperatorv1.ServiceCatalogControllerManagerApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.ServiceCatalogControllerManager, err error) + ServiceCatalogControllerManagerExpansion +} + +// serviceCatalogControllerManagers implements ServiceCatalogControllerManagerInterface +type serviceCatalogControllerManagers struct { + *gentype.ClientWithListAndApply[*operatorv1.ServiceCatalogControllerManager, *operatorv1.ServiceCatalogControllerManagerList, *applyconfigurationsoperatorv1.ServiceCatalogControllerManagerApplyConfiguration] +} + +// newServiceCatalogControllerManagers returns a ServiceCatalogControllerManagers +func newServiceCatalogControllerManagers(c *OperatorV1Client) *serviceCatalogControllerManagers { + return &serviceCatalogControllerManagers{ + gentype.NewClientWithListAndApply[*operatorv1.ServiceCatalogControllerManager, *operatorv1.ServiceCatalogControllerManagerList, *applyconfigurationsoperatorv1.ServiceCatalogControllerManagerApplyConfiguration]( + "servicecatalogcontrollermanagers", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.ServiceCatalogControllerManager { + return &operatorv1.ServiceCatalogControllerManager{} + }, + func() *operatorv1.ServiceCatalogControllerManagerList { + return &operatorv1.ServiceCatalogControllerManagerList{} + }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/storage.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/storage.go new file mode 100644 index 0000000000..e1110785fc --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/storage.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + + operatorv1 "github.com/openshift/api/operator/v1" + applyconfigurationsoperatorv1 "github.com/openshift/client-go/operator/applyconfigurations/operator/v1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + gentype "k8s.io/client-go/gentype" +) + +// StoragesGetter has a method to return a StorageInterface. +// A group's client should implement this interface. +type StoragesGetter interface { + Storages() StorageInterface +} + +// StorageInterface has methods to work with Storage resources. +type StorageInterface interface { + Create(ctx context.Context, storage *operatorv1.Storage, opts metav1.CreateOptions) (*operatorv1.Storage, error) + Update(ctx context.Context, storage *operatorv1.Storage, opts metav1.UpdateOptions) (*operatorv1.Storage, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, storage *operatorv1.Storage, opts metav1.UpdateOptions) (*operatorv1.Storage, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*operatorv1.Storage, error) + List(ctx context.Context, opts metav1.ListOptions) (*operatorv1.StorageList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *operatorv1.Storage, err error) + Apply(ctx context.Context, storage *applyconfigurationsoperatorv1.StorageApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Storage, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, storage *applyconfigurationsoperatorv1.StorageApplyConfiguration, opts metav1.ApplyOptions) (result *operatorv1.Storage, err error) + StorageExpansion +} + +// storages implements StorageInterface +type storages struct { + *gentype.ClientWithListAndApply[*operatorv1.Storage, *operatorv1.StorageList, *applyconfigurationsoperatorv1.StorageApplyConfiguration] +} + +// newStorages returns a Storages +func newStorages(c *OperatorV1Client) *storages { + return &storages{ + gentype.NewClientWithListAndApply[*operatorv1.Storage, *operatorv1.StorageList, *applyconfigurationsoperatorv1.StorageApplyConfiguration]( + "storages", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1.Storage { return &operatorv1.Storage{} }, + func() *operatorv1.StorageList { return &operatorv1.StorageList{} }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/clusterversionoperator.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/clusterversionoperator.go new file mode 100644 index 0000000000..f55e610094 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/clusterversionoperator.go @@ -0,0 +1,60 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + applyconfigurationsoperatorv1alpha1 "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" + gentype "k8s.io/client-go/gentype" +) + +// ClusterVersionOperatorsGetter has a method to return a ClusterVersionOperatorInterface. +// A group's client should implement this interface. +type ClusterVersionOperatorsGetter interface { + ClusterVersionOperators() ClusterVersionOperatorInterface +} + +// ClusterVersionOperatorInterface has methods to work with ClusterVersionOperator resources. +type ClusterVersionOperatorInterface interface { + Create(ctx context.Context, clusterVersionOperator *operatorv1alpha1.ClusterVersionOperator, opts v1.CreateOptions) (*operatorv1alpha1.ClusterVersionOperator, error) + Update(ctx context.Context, clusterVersionOperator *operatorv1alpha1.ClusterVersionOperator, opts v1.UpdateOptions) (*operatorv1alpha1.ClusterVersionOperator, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, clusterVersionOperator *operatorv1alpha1.ClusterVersionOperator, opts v1.UpdateOptions) (*operatorv1alpha1.ClusterVersionOperator, 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) (*operatorv1alpha1.ClusterVersionOperator, error) + List(ctx context.Context, opts v1.ListOptions) (*operatorv1alpha1.ClusterVersionOperatorList, 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 *operatorv1alpha1.ClusterVersionOperator, err error) + Apply(ctx context.Context, clusterVersionOperator *applyconfigurationsoperatorv1alpha1.ClusterVersionOperatorApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.ClusterVersionOperator, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, clusterVersionOperator *applyconfigurationsoperatorv1alpha1.ClusterVersionOperatorApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.ClusterVersionOperator, err error) + ClusterVersionOperatorExpansion +} + +// clusterVersionOperators implements ClusterVersionOperatorInterface +type clusterVersionOperators struct { + *gentype.ClientWithListAndApply[*operatorv1alpha1.ClusterVersionOperator, *operatorv1alpha1.ClusterVersionOperatorList, *applyconfigurationsoperatorv1alpha1.ClusterVersionOperatorApplyConfiguration] +} + +// newClusterVersionOperators returns a ClusterVersionOperators +func newClusterVersionOperators(c *OperatorV1alpha1Client) *clusterVersionOperators { + return &clusterVersionOperators{ + gentype.NewClientWithListAndApply[*operatorv1alpha1.ClusterVersionOperator, *operatorv1alpha1.ClusterVersionOperatorList, *applyconfigurationsoperatorv1alpha1.ClusterVersionOperatorApplyConfiguration]( + "clusterversionoperators", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1alpha1.ClusterVersionOperator { return &operatorv1alpha1.ClusterVersionOperator{} }, + func() *operatorv1alpha1.ClusterVersionOperatorList { + return &operatorv1alpha1.ClusterVersionOperatorList{} + }, + ), + } +} 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 0000000000..93a7ca4e0e --- /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/etcdbackup.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/etcdbackup.go new file mode 100644 index 0000000000..cc2889e44b --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/etcdbackup.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + applyconfigurationsoperatorv1alpha1 "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" + gentype "k8s.io/client-go/gentype" +) + +// EtcdBackupsGetter has a method to return a EtcdBackupInterface. +// A group's client should implement this interface. +type EtcdBackupsGetter interface { + EtcdBackups() EtcdBackupInterface +} + +// EtcdBackupInterface has methods to work with EtcdBackup resources. +type EtcdBackupInterface interface { + Create(ctx context.Context, etcdBackup *operatorv1alpha1.EtcdBackup, opts v1.CreateOptions) (*operatorv1alpha1.EtcdBackup, error) + Update(ctx context.Context, etcdBackup *operatorv1alpha1.EtcdBackup, opts v1.UpdateOptions) (*operatorv1alpha1.EtcdBackup, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, etcdBackup *operatorv1alpha1.EtcdBackup, opts v1.UpdateOptions) (*operatorv1alpha1.EtcdBackup, 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) (*operatorv1alpha1.EtcdBackup, error) + List(ctx context.Context, opts v1.ListOptions) (*operatorv1alpha1.EtcdBackupList, 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 *operatorv1alpha1.EtcdBackup, err error) + Apply(ctx context.Context, etcdBackup *applyconfigurationsoperatorv1alpha1.EtcdBackupApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.EtcdBackup, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, etcdBackup *applyconfigurationsoperatorv1alpha1.EtcdBackupApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.EtcdBackup, err error) + EtcdBackupExpansion +} + +// etcdBackups implements EtcdBackupInterface +type etcdBackups struct { + *gentype.ClientWithListAndApply[*operatorv1alpha1.EtcdBackup, *operatorv1alpha1.EtcdBackupList, *applyconfigurationsoperatorv1alpha1.EtcdBackupApplyConfiguration] +} + +// newEtcdBackups returns a EtcdBackups +func newEtcdBackups(c *OperatorV1alpha1Client) *etcdBackups { + return &etcdBackups{ + gentype.NewClientWithListAndApply[*operatorv1alpha1.EtcdBackup, *operatorv1alpha1.EtcdBackupList, *applyconfigurationsoperatorv1alpha1.EtcdBackupApplyConfiguration]( + "etcdbackups", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1alpha1.EtcdBackup { return &operatorv1alpha1.EtcdBackup{} }, + func() *operatorv1alpha1.EtcdBackupList { return &operatorv1alpha1.EtcdBackupList{} }, + ), + } +} 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 0000000000..33de3f9657 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/generated_expansion.go @@ -0,0 +1,11 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +type ClusterVersionOperatorExpansion interface{} + +type EtcdBackupExpansion interface{} + +type ImageContentSourcePolicyExpansion interface{} + +type OLMExpansion 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 0000000000..8073b59e15 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,56 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + applyconfigurationsoperatorv1alpha1 "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" + gentype "k8s.io/client-go/gentype" +) + +// 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 *operatorv1alpha1.ImageContentSourcePolicy, opts v1.CreateOptions) (*operatorv1alpha1.ImageContentSourcePolicy, error) + Update(ctx context.Context, imageContentSourcePolicy *operatorv1alpha1.ImageContentSourcePolicy, opts v1.UpdateOptions) (*operatorv1alpha1.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) (*operatorv1alpha1.ImageContentSourcePolicy, error) + List(ctx context.Context, opts v1.ListOptions) (*operatorv1alpha1.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 *operatorv1alpha1.ImageContentSourcePolicy, err error) + Apply(ctx context.Context, imageContentSourcePolicy *applyconfigurationsoperatorv1alpha1.ImageContentSourcePolicyApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.ImageContentSourcePolicy, err error) + ImageContentSourcePolicyExpansion +} + +// imageContentSourcePolicies implements ImageContentSourcePolicyInterface +type imageContentSourcePolicies struct { + *gentype.ClientWithListAndApply[*operatorv1alpha1.ImageContentSourcePolicy, *operatorv1alpha1.ImageContentSourcePolicyList, *applyconfigurationsoperatorv1alpha1.ImageContentSourcePolicyApplyConfiguration] +} + +// newImageContentSourcePolicies returns a ImageContentSourcePolicies +func newImageContentSourcePolicies(c *OperatorV1alpha1Client) *imageContentSourcePolicies { + return &imageContentSourcePolicies{ + gentype.NewClientWithListAndApply[*operatorv1alpha1.ImageContentSourcePolicy, *operatorv1alpha1.ImageContentSourcePolicyList, *applyconfigurationsoperatorv1alpha1.ImageContentSourcePolicyApplyConfiguration]( + "imagecontentsourcepolicies", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1alpha1.ImageContentSourcePolicy { return &operatorv1alpha1.ImageContentSourcePolicy{} }, + func() *operatorv1alpha1.ImageContentSourcePolicyList { + return &operatorv1alpha1.ImageContentSourcePolicyList{} + }, + ), + } +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/olm.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/olm.go new file mode 100644 index 0000000000..6a8bfd05cb --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/olm.go @@ -0,0 +1,58 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + applyconfigurationsoperatorv1alpha1 "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" + gentype "k8s.io/client-go/gentype" +) + +// OLMsGetter has a method to return a OLMInterface. +// A group's client should implement this interface. +type OLMsGetter interface { + OLMs() OLMInterface +} + +// OLMInterface has methods to work with OLM resources. +type OLMInterface interface { + Create(ctx context.Context, oLM *operatorv1alpha1.OLM, opts v1.CreateOptions) (*operatorv1alpha1.OLM, error) + Update(ctx context.Context, oLM *operatorv1alpha1.OLM, opts v1.UpdateOptions) (*operatorv1alpha1.OLM, error) + // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). + UpdateStatus(ctx context.Context, oLM *operatorv1alpha1.OLM, opts v1.UpdateOptions) (*operatorv1alpha1.OLM, 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) (*operatorv1alpha1.OLM, error) + List(ctx context.Context, opts v1.ListOptions) (*operatorv1alpha1.OLMList, 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 *operatorv1alpha1.OLM, err error) + Apply(ctx context.Context, oLM *applyconfigurationsoperatorv1alpha1.OLMApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.OLM, err error) + // Add a +genclient:noStatus comment above the type to avoid generating ApplyStatus(). + ApplyStatus(ctx context.Context, oLM *applyconfigurationsoperatorv1alpha1.OLMApplyConfiguration, opts v1.ApplyOptions) (result *operatorv1alpha1.OLM, err error) + OLMExpansion +} + +// oLMs implements OLMInterface +type oLMs struct { + *gentype.ClientWithListAndApply[*operatorv1alpha1.OLM, *operatorv1alpha1.OLMList, *applyconfigurationsoperatorv1alpha1.OLMApplyConfiguration] +} + +// newOLMs returns a OLMs +func newOLMs(c *OperatorV1alpha1Client) *oLMs { + return &oLMs{ + gentype.NewClientWithListAndApply[*operatorv1alpha1.OLM, *operatorv1alpha1.OLMList, *applyconfigurationsoperatorv1alpha1.OLMApplyConfiguration]( + "olms", + c.RESTClient(), + scheme.ParameterCodec, + "", + func() *operatorv1alpha1.OLM { return &operatorv1alpha1.OLM{} }, + func() *operatorv1alpha1.OLMList { return &operatorv1alpha1.OLMList{} }, + ), + } +} 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 0000000000..f9db341b13 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/operator_client.go @@ -0,0 +1,106 @@ +// Code generated by client-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + http "net/http" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + scheme "github.com/openshift/client-go/operator/clientset/versioned/scheme" + rest "k8s.io/client-go/rest" +) + +type OperatorV1alpha1Interface interface { + RESTClient() rest.Interface + ClusterVersionOperatorsGetter + EtcdBackupsGetter + ImageContentSourcePoliciesGetter + OLMsGetter +} + +// OperatorV1alpha1Client is used to interact with features provided by the operator.openshift.io group. +type OperatorV1alpha1Client struct { + restClient rest.Interface +} + +func (c *OperatorV1alpha1Client) ClusterVersionOperators() ClusterVersionOperatorInterface { + return newClusterVersionOperators(c) +} + +func (c *OperatorV1alpha1Client) EtcdBackups() EtcdBackupInterface { + return newEtcdBackups(c) +} + +func (c *OperatorV1alpha1Client) ImageContentSourcePolicies() ImageContentSourcePolicyInterface { + return newImageContentSourcePolicies(c) +} + +func (c *OperatorV1alpha1Client) OLMs() OLMInterface { + return newOLMs(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 := operatorv1alpha1.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = rest.CodecFactoryForGeneratedClient(scheme.Scheme, 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 0000000000..642d1b34e6 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/factory.go @@ -0,0 +1,246 @@ +// 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 + transform cache.TransformFunc + + 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 + // wg tracks how many goroutines were started. + wg sync.WaitGroup + // shuttingDown is true when Shutdown has been called. It may still be running + // because it needs to wait for goroutines. + shuttingDown 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 + } +} + +// WithTransform sets a transform on all informers. +func WithTransform(transform cache.TransformFunc) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.transform = transform + 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 +} + +func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) { + f.lock.Lock() + defer f.lock.Unlock() + + if f.shuttingDown { + return + } + + for informerType, informer := range f.informers { + if !f.startedInformers[informerType] { + f.wg.Add(1) + // We need a new variable in each loop iteration, + // otherwise the goroutine would use the loop variable + // and that keeps changing. + informer := informer + go func() { + defer f.wg.Done() + informer.Run(stopCh) + }() + f.startedInformers[informerType] = true + } + } +} + +func (f *sharedInformerFactory) Shutdown() { + f.lock.Lock() + f.shuttingDown = true + f.lock.Unlock() + + // Will return immediately if there is nothing to wait for. + f.wg.Wait() +} + +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 +} + +// InformerFor 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) + informer.SetTransform(f.transform) + f.informers[informerType] = informer + + return informer +} + +// SharedInformerFactory provides shared informers for resources in all known +// API group versions. +// +// It is typically used like this: +// +// ctx, cancel := context.Background() +// defer cancel() +// factory := NewSharedInformerFactory(client, resyncPeriod) +// defer factory.WaitForStop() // Returns immediately if nothing was started. +// genericInformer := factory.ForResource(resource) +// typedInformer := factory.SomeAPIGroup().V1().SomeType() +// factory.Start(ctx.Done()) // Start processing these informers. +// synced := factory.WaitForCacheSync(ctx.Done()) +// for v, ok := range synced { +// if !ok { +// fmt.Fprintf(os.Stderr, "caches failed to sync: %v", v) +// return +// } +// } +// +// // Creating informers can also be created after Start, but then +// // Start must be called again: +// anotherGenericInformer := factory.ForResource(resource) +// factory.Start(ctx.Done()) +type SharedInformerFactory interface { + internalinterfaces.SharedInformerFactory + + // Start initializes all requested informers. They are handled in goroutines + // which run until the stop channel gets closed. + // Warning: Start does not block. When run in a go-routine, it will race with a later WaitForCacheSync. + Start(stopCh <-chan struct{}) + + // Shutdown marks a factory as shutting down. At that point no new + // informers can be started anymore and Start will return without + // doing anything. + // + // In addition, Shutdown blocks until all goroutines have terminated. For that + // to happen, the close channel(s) that they were started with must be closed, + // either before Shutdown gets called or while it is waiting. + // + // Shutdown may be called multiple times, even concurrently. All such calls will + // block until all goroutines have terminated. + Shutdown() + + // WaitForCacheSync blocks until all started informers' caches were synced + // or the stop channel gets closed. + WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool + + // ForResource gives generic access to a shared informer of the matching type. + ForResource(resource schema.GroupVersionResource) (GenericInformer, error) + + // InformerFor returns the SharedIndexInformer for obj using an internal + // client. + InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer + + 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 0000000000..9ef7b51e11 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/generic.go @@ -0,0 +1,101 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package externalversions + +import ( + fmt "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("machineconfigurations"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().MachineConfigurations().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("networks"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().Networks().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("olms"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1().OLMs().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("clusterversionoperators"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().ClusterVersionOperators().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("etcdbackups"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().EtcdBackups().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("imagecontentsourcepolicies"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().ImageContentSourcePolicies().Informer()}, nil + case v1alpha1.SchemeGroupVersion.WithResource("olms"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Operator().V1alpha1().OLMs().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 0000000000..bf4618167f --- /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 0000000000..4da3da1580 --- /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 0000000000..6fb982888d --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.Authentication{}, f.defaultInformer) +} + +func (f *authenticationInformer) Lister() operatorv1.AuthenticationLister { + return operatorv1.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 0000000000..c3aa02afd1 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.CloudCredential{}, f.defaultInformer) +} + +func (f *cloudCredentialInformer) Lister() operatorv1.CloudCredentialLister { + return operatorv1.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 0000000000..c9cf5143ed --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.ClusterCSIDriver{}, f.defaultInformer) +} + +func (f *clusterCSIDriverInformer) Lister() operatorv1.ClusterCSIDriverLister { + return operatorv1.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 0000000000..6af4ed2d3c --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.Config{}, f.defaultInformer) +} + +func (f *configInformer) Lister() operatorv1.ConfigLister { + return operatorv1.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 0000000000..18c8244578 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.Console{}, f.defaultInformer) +} + +func (f *consoleInformer) Lister() operatorv1.ConsoleLister { + return operatorv1.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 0000000000..ca889d29cd --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.CSISnapshotController{}, f.defaultInformer) +} + +func (f *cSISnapshotControllerInformer) Lister() operatorv1.CSISnapshotControllerLister { + return operatorv1.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 0000000000..a97b100640 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.DNS{}, f.defaultInformer) +} + +func (f *dNSInformer) Lister() operatorv1.DNSLister { + return operatorv1.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 0000000000..e410bd016e --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.Etcd{}, f.defaultInformer) +} + +func (f *etcdInformer) Lister() operatorv1.EtcdLister { + return operatorv1.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 0000000000..daa94221e4 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.IngressController{}, f.defaultInformer) +} + +func (f *ingressControllerInformer) Lister() operatorv1.IngressControllerLister { + return operatorv1.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 0000000000..1ea8c183ae --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.InsightsOperator{}, f.defaultInformer) +} + +func (f *insightsOperatorInformer) Lister() operatorv1.InsightsOperatorLister { + return operatorv1.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 0000000000..c5169b9fb9 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/interface.go @@ -0,0 +1,183 @@ +// 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 + // MachineConfigurations returns a MachineConfigurationInformer. + MachineConfigurations() MachineConfigurationInformer + // Networks returns a NetworkInformer. + Networks() NetworkInformer + // OLMs returns a OLMInformer. + OLMs() OLMInformer + // 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} +} + +// MachineConfigurations returns a MachineConfigurationInformer. +func (v *version) MachineConfigurations() MachineConfigurationInformer { + return &machineConfigurationInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// Networks returns a NetworkInformer. +func (v *version) Networks() NetworkInformer { + return &networkInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// OLMs returns a OLMInformer. +func (v *version) OLMs() OLMInformer { + return &oLMInformer{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 0000000000..21ffb7900f --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.KubeAPIServer{}, f.defaultInformer) +} + +func (f *kubeAPIServerInformer) Lister() operatorv1.KubeAPIServerLister { + return operatorv1.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 0000000000..3554d60f5c --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.KubeControllerManager{}, f.defaultInformer) +} + +func (f *kubeControllerManagerInformer) Lister() operatorv1.KubeControllerManagerLister { + return operatorv1.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 0000000000..cf1dac5a79 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.KubeScheduler{}, f.defaultInformer) +} + +func (f *kubeSchedulerInformer) Lister() operatorv1.KubeSchedulerLister { + return operatorv1.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 0000000000..0693a366b0 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.KubeStorageVersionMigrator{}, f.defaultInformer) +} + +func (f *kubeStorageVersionMigratorInformer) Lister() operatorv1.KubeStorageVersionMigratorLister { + return operatorv1.NewKubeStorageVersionMigratorLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/machineconfiguration.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/machineconfiguration.go new file mode 100644 index 0000000000..07180912b5 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/machineconfiguration.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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" +) + +// MachineConfigurationInformer provides access to a shared informer and lister for +// MachineConfigurations. +type MachineConfigurationInformer interface { + Informer() cache.SharedIndexInformer + Lister() operatorv1.MachineConfigurationLister +} + +type machineConfigurationInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewMachineConfigurationInformer constructs a new informer for MachineConfiguration 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 NewMachineConfigurationInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredMachineConfigurationInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredMachineConfigurationInformer constructs a new informer for MachineConfiguration 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 NewFilteredMachineConfigurationInformer(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().MachineConfigurations().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().MachineConfigurations().Watch(context.TODO(), options) + }, + }, + &apioperatorv1.MachineConfiguration{}, + resyncPeriod, + indexers, + ) +} + +func (f *machineConfigurationInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredMachineConfigurationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *machineConfigurationInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apioperatorv1.MachineConfiguration{}, f.defaultInformer) +} + +func (f *machineConfigurationInformer) Lister() operatorv1.MachineConfigurationLister { + return operatorv1.NewMachineConfigurationLister(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 0000000000..8b2342c7de --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.Network{}, f.defaultInformer) +} + +func (f *networkInformer) Lister() operatorv1.NetworkLister { + return operatorv1.NewNetworkLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/olm.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/olm.go new file mode 100644 index 0000000000..dbfeca0714 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1/olm.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + context "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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" +) + +// OLMInformer provides access to a shared informer and lister for +// OLMs. +type OLMInformer interface { + Informer() cache.SharedIndexInformer + Lister() operatorv1.OLMLister +} + +type oLMInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewOLMInformer constructs a new informer for OLM 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 NewOLMInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredOLMInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredOLMInformer constructs a new informer for OLM 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 NewFilteredOLMInformer(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().OLMs().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1().OLMs().Watch(context.TODO(), options) + }, + }, + &apioperatorv1.OLM{}, + resyncPeriod, + indexers, + ) +} + +func (f *oLMInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredOLMInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *oLMInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apioperatorv1.OLM{}, f.defaultInformer) +} + +func (f *oLMInformer) Lister() operatorv1.OLMLister { + return operatorv1.NewOLMLister(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 0000000000..56d0e087ee --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.OpenShiftAPIServer{}, f.defaultInformer) +} + +func (f *openShiftAPIServerInformer) Lister() operatorv1.OpenShiftAPIServerLister { + return operatorv1.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 0000000000..27a3231691 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.OpenShiftControllerManager{}, f.defaultInformer) +} + +func (f *openShiftControllerManagerInformer) Lister() operatorv1.OpenShiftControllerManagerLister { + return operatorv1.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 0000000000..5676dc15ca --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.ServiceCA{}, f.defaultInformer) +} + +func (f *serviceCAInformer) Lister() operatorv1.ServiceCALister { + return operatorv1.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 0000000000..8a13dfbb96 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.ServiceCatalogAPIServer{}, f.defaultInformer) +} + +func (f *serviceCatalogAPIServerInformer) Lister() operatorv1.ServiceCatalogAPIServerLister { + return operatorv1.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 0000000000..e527150c32 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.ServiceCatalogControllerManager{}, f.defaultInformer) +} + +func (f *serviceCatalogControllerManagerInformer) Lister() operatorv1.ServiceCatalogControllerManagerLister { + return operatorv1.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 0000000000..4f6c6b3313 --- /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 "context" + time "time" + + apioperatorv1 "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" + operatorv1 "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() operatorv1.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) + }, + }, + &apioperatorv1.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(&apioperatorv1.Storage{}, f.defaultInformer) +} + +func (f *storageInformer) Lister() operatorv1.StorageLister { + return operatorv1.NewStorageLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/clusterversionoperator.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/clusterversionoperator.go new file mode 100644 index 0000000000..134f9a2a7d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/clusterversionoperator.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + time "time" + + apioperatorv1alpha1 "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" + operatorv1alpha1 "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" +) + +// ClusterVersionOperatorInformer provides access to a shared informer and lister for +// ClusterVersionOperators. +type ClusterVersionOperatorInformer interface { + Informer() cache.SharedIndexInformer + Lister() operatorv1alpha1.ClusterVersionOperatorLister +} + +type clusterVersionOperatorInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewClusterVersionOperatorInformer constructs a new informer for ClusterVersionOperator 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 NewClusterVersionOperatorInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredClusterVersionOperatorInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredClusterVersionOperatorInformer constructs a new informer for ClusterVersionOperator 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 NewFilteredClusterVersionOperatorInformer(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().ClusterVersionOperators().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1alpha1().ClusterVersionOperators().Watch(context.TODO(), options) + }, + }, + &apioperatorv1alpha1.ClusterVersionOperator{}, + resyncPeriod, + indexers, + ) +} + +func (f *clusterVersionOperatorInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredClusterVersionOperatorInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *clusterVersionOperatorInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apioperatorv1alpha1.ClusterVersionOperator{}, f.defaultInformer) +} + +func (f *clusterVersionOperatorInformer) Lister() operatorv1alpha1.ClusterVersionOperatorLister { + return operatorv1alpha1.NewClusterVersionOperatorLister(f.Informer().GetIndexer()) +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/etcdbackup.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/etcdbackup.go new file mode 100644 index 0000000000..2558b9b24e --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/etcdbackup.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + time "time" + + apioperatorv1alpha1 "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" + operatorv1alpha1 "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" +) + +// EtcdBackupInformer provides access to a shared informer and lister for +// EtcdBackups. +type EtcdBackupInformer interface { + Informer() cache.SharedIndexInformer + Lister() operatorv1alpha1.EtcdBackupLister +} + +type etcdBackupInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewEtcdBackupInformer constructs a new informer for EtcdBackup 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 NewEtcdBackupInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredEtcdBackupInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredEtcdBackupInformer constructs a new informer for EtcdBackup 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 NewFilteredEtcdBackupInformer(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().EtcdBackups().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1alpha1().EtcdBackups().Watch(context.TODO(), options) + }, + }, + &apioperatorv1alpha1.EtcdBackup{}, + resyncPeriod, + indexers, + ) +} + +func (f *etcdBackupInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredEtcdBackupInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *etcdBackupInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apioperatorv1alpha1.EtcdBackup{}, f.defaultInformer) +} + +func (f *etcdBackupInformer) Lister() operatorv1alpha1.EtcdBackupLister { + return operatorv1alpha1.NewEtcdBackupLister(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 0000000000..b5d4fcf067 --- /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 "context" + time "time" + + apioperatorv1alpha1 "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" + operatorv1alpha1 "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() operatorv1alpha1.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) + }, + }, + &apioperatorv1alpha1.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(&apioperatorv1alpha1.ImageContentSourcePolicy{}, f.defaultInformer) +} + +func (f *imageContentSourcePolicyInformer) Lister() operatorv1alpha1.ImageContentSourcePolicyLister { + return operatorv1alpha1.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 0000000000..3b52c11824 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/interface.go @@ -0,0 +1,50 @@ +// 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 { + // ClusterVersionOperators returns a ClusterVersionOperatorInformer. + ClusterVersionOperators() ClusterVersionOperatorInformer + // EtcdBackups returns a EtcdBackupInformer. + EtcdBackups() EtcdBackupInformer + // ImageContentSourcePolicies returns a ImageContentSourcePolicyInformer. + ImageContentSourcePolicies() ImageContentSourcePolicyInformer + // OLMs returns a OLMInformer. + OLMs() OLMInformer +} + +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} +} + +// ClusterVersionOperators returns a ClusterVersionOperatorInformer. +func (v *version) ClusterVersionOperators() ClusterVersionOperatorInformer { + return &clusterVersionOperatorInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// EtcdBackups returns a EtcdBackupInformer. +func (v *version) EtcdBackups() EtcdBackupInformer { + return &etcdBackupInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// ImageContentSourcePolicies returns a ImageContentSourcePolicyInformer. +func (v *version) ImageContentSourcePolicies() ImageContentSourcePolicyInformer { + return &imageContentSourcePolicyInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} + +// OLMs returns a OLMInformer. +func (v *version) OLMs() OLMInformer { + return &oLMInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/olm.go b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/olm.go new file mode 100644 index 0000000000..1bce2de82c --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/informers/externalversions/operator/v1alpha1/olm.go @@ -0,0 +1,73 @@ +// Code generated by informer-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + context "context" + time "time" + + apioperatorv1alpha1 "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" + operatorv1alpha1 "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" +) + +// OLMInformer provides access to a shared informer and lister for +// OLMs. +type OLMInformer interface { + Informer() cache.SharedIndexInformer + Lister() operatorv1alpha1.OLMLister +} + +type oLMInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewOLMInformer constructs a new informer for OLM 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 NewOLMInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredOLMInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredOLMInformer constructs a new informer for OLM 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 NewFilteredOLMInformer(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().OLMs().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.OperatorV1alpha1().OLMs().Watch(context.TODO(), options) + }, + }, + &apioperatorv1alpha1.OLM{}, + resyncPeriod, + indexers, + ) +} + +func (f *oLMInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredOLMInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *oLMInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apioperatorv1alpha1.OLM{}, f.defaultInformer) +} + +func (f *oLMInformer) Lister() operatorv1alpha1.OLMLister { + return operatorv1alpha1.NewOLMLister(f.Informer().GetIndexer()) +} 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 0000000000..1b77a086e8 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/authentication.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.Authentication, error) + AuthenticationListerExpansion +} + +// authenticationLister implements the AuthenticationLister interface. +type authenticationLister struct { + listers.ResourceIndexer[*operatorv1.Authentication] +} + +// NewAuthenticationLister returns a new AuthenticationLister. +func NewAuthenticationLister(indexer cache.Indexer) AuthenticationLister { + return &authenticationLister{listers.New[*operatorv1.Authentication](indexer, operatorv1.Resource("authentication"))} +} 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 0000000000..b968bbee4d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/cloudcredential.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.CloudCredential, error) + CloudCredentialListerExpansion +} + +// cloudCredentialLister implements the CloudCredentialLister interface. +type cloudCredentialLister struct { + listers.ResourceIndexer[*operatorv1.CloudCredential] +} + +// NewCloudCredentialLister returns a new CloudCredentialLister. +func NewCloudCredentialLister(indexer cache.Indexer) CloudCredentialLister { + return &cloudCredentialLister{listers.New[*operatorv1.CloudCredential](indexer, operatorv1.Resource("cloudcredential"))} +} 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 0000000000..d28e7f1e95 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/clustercsidriver.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.ClusterCSIDriver, error) + ClusterCSIDriverListerExpansion +} + +// clusterCSIDriverLister implements the ClusterCSIDriverLister interface. +type clusterCSIDriverLister struct { + listers.ResourceIndexer[*operatorv1.ClusterCSIDriver] +} + +// NewClusterCSIDriverLister returns a new ClusterCSIDriverLister. +func NewClusterCSIDriverLister(indexer cache.Indexer) ClusterCSIDriverLister { + return &clusterCSIDriverLister{listers.New[*operatorv1.ClusterCSIDriver](indexer, operatorv1.Resource("clustercsidriver"))} +} 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 0000000000..916abbb4e6 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/config.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.Config, error) + ConfigListerExpansion +} + +// configLister implements the ConfigLister interface. +type configLister struct { + listers.ResourceIndexer[*operatorv1.Config] +} + +// NewConfigLister returns a new ConfigLister. +func NewConfigLister(indexer cache.Indexer) ConfigLister { + return &configLister{listers.New[*operatorv1.Config](indexer, operatorv1.Resource("config"))} +} 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 0000000000..45b9e36721 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/console.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.Console, error) + ConsoleListerExpansion +} + +// consoleLister implements the ConsoleLister interface. +type consoleLister struct { + listers.ResourceIndexer[*operatorv1.Console] +} + +// NewConsoleLister returns a new ConsoleLister. +func NewConsoleLister(indexer cache.Indexer) ConsoleLister { + return &consoleLister{listers.New[*operatorv1.Console](indexer, operatorv1.Resource("console"))} +} 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 0000000000..a73ca72e59 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/csisnapshotcontroller.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.CSISnapshotController, error) + CSISnapshotControllerListerExpansion +} + +// cSISnapshotControllerLister implements the CSISnapshotControllerLister interface. +type cSISnapshotControllerLister struct { + listers.ResourceIndexer[*operatorv1.CSISnapshotController] +} + +// NewCSISnapshotControllerLister returns a new CSISnapshotControllerLister. +func NewCSISnapshotControllerLister(indexer cache.Indexer) CSISnapshotControllerLister { + return &cSISnapshotControllerLister{listers.New[*operatorv1.CSISnapshotController](indexer, operatorv1.Resource("csisnapshotcontroller"))} +} 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 0000000000..4ecdd8bb03 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/dns.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.DNS, error) + DNSListerExpansion +} + +// dNSLister implements the DNSLister interface. +type dNSLister struct { + listers.ResourceIndexer[*operatorv1.DNS] +} + +// NewDNSLister returns a new DNSLister. +func NewDNSLister(indexer cache.Indexer) DNSLister { + return &dNSLister{listers.New[*operatorv1.DNS](indexer, operatorv1.Resource("dns"))} +} 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 0000000000..0708fcf852 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/etcd.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.Etcd, error) + EtcdListerExpansion +} + +// etcdLister implements the EtcdLister interface. +type etcdLister struct { + listers.ResourceIndexer[*operatorv1.Etcd] +} + +// NewEtcdLister returns a new EtcdLister. +func NewEtcdLister(indexer cache.Indexer) EtcdLister { + return &etcdLister{listers.New[*operatorv1.Etcd](indexer, operatorv1.Resource("etcd"))} +} 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 0000000000..9690ac240a --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/expansion_generated.go @@ -0,0 +1,99 @@ +// 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{} + +// MachineConfigurationListerExpansion allows custom methods to be added to +// MachineConfigurationLister. +type MachineConfigurationListerExpansion interface{} + +// NetworkListerExpansion allows custom methods to be added to +// NetworkLister. +type NetworkListerExpansion interface{} + +// OLMListerExpansion allows custom methods to be added to +// OLMLister. +type OLMListerExpansion 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 0000000000..322952fd7b --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/ingresscontroller.go @@ -0,0 +1,54 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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 { + listers.ResourceIndexer[*operatorv1.IngressController] +} + +// NewIngressControllerLister returns a new IngressControllerLister. +func NewIngressControllerLister(indexer cache.Indexer) IngressControllerLister { + return &ingressControllerLister{listers.New[*operatorv1.IngressController](indexer, operatorv1.Resource("ingresscontroller"))} +} + +// IngressControllers returns an object that can list and get IngressControllers. +func (s *ingressControllerLister) IngressControllers(namespace string) IngressControllerNamespaceLister { + return ingressControllerNamespaceLister{listers.NewNamespaced[*operatorv1.IngressController](s.ResourceIndexer, 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 []*operatorv1.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) (*operatorv1.IngressController, error) + IngressControllerNamespaceListerExpansion +} + +// ingressControllerNamespaceLister implements the IngressControllerNamespaceLister +// interface. +type ingressControllerNamespaceLister struct { + listers.ResourceIndexer[*operatorv1.IngressController] +} 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 0000000000..0a79b9aa05 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/insightsoperator.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.InsightsOperator, error) + InsightsOperatorListerExpansion +} + +// insightsOperatorLister implements the InsightsOperatorLister interface. +type insightsOperatorLister struct { + listers.ResourceIndexer[*operatorv1.InsightsOperator] +} + +// NewInsightsOperatorLister returns a new InsightsOperatorLister. +func NewInsightsOperatorLister(indexer cache.Indexer) InsightsOperatorLister { + return &insightsOperatorLister{listers.New[*operatorv1.InsightsOperator](indexer, operatorv1.Resource("insightsoperator"))} +} 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 0000000000..99744ebc3d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubeapiserver.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.KubeAPIServer, error) + KubeAPIServerListerExpansion +} + +// kubeAPIServerLister implements the KubeAPIServerLister interface. +type kubeAPIServerLister struct { + listers.ResourceIndexer[*operatorv1.KubeAPIServer] +} + +// NewKubeAPIServerLister returns a new KubeAPIServerLister. +func NewKubeAPIServerLister(indexer cache.Indexer) KubeAPIServerLister { + return &kubeAPIServerLister{listers.New[*operatorv1.KubeAPIServer](indexer, operatorv1.Resource("kubeapiserver"))} +} 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 0000000000..dbca5fea81 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubecontrollermanager.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.KubeControllerManager, error) + KubeControllerManagerListerExpansion +} + +// kubeControllerManagerLister implements the KubeControllerManagerLister interface. +type kubeControllerManagerLister struct { + listers.ResourceIndexer[*operatorv1.KubeControllerManager] +} + +// NewKubeControllerManagerLister returns a new KubeControllerManagerLister. +func NewKubeControllerManagerLister(indexer cache.Indexer) KubeControllerManagerLister { + return &kubeControllerManagerLister{listers.New[*operatorv1.KubeControllerManager](indexer, operatorv1.Resource("kubecontrollermanager"))} +} 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 0000000000..2c9ca49f63 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubescheduler.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.KubeScheduler, error) + KubeSchedulerListerExpansion +} + +// kubeSchedulerLister implements the KubeSchedulerLister interface. +type kubeSchedulerLister struct { + listers.ResourceIndexer[*operatorv1.KubeScheduler] +} + +// NewKubeSchedulerLister returns a new KubeSchedulerLister. +func NewKubeSchedulerLister(indexer cache.Indexer) KubeSchedulerLister { + return &kubeSchedulerLister{listers.New[*operatorv1.KubeScheduler](indexer, operatorv1.Resource("kubescheduler"))} +} 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 0000000000..0f00042e73 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/kubestorageversionmigrator.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.KubeStorageVersionMigrator, error) + KubeStorageVersionMigratorListerExpansion +} + +// kubeStorageVersionMigratorLister implements the KubeStorageVersionMigratorLister interface. +type kubeStorageVersionMigratorLister struct { + listers.ResourceIndexer[*operatorv1.KubeStorageVersionMigrator] +} + +// NewKubeStorageVersionMigratorLister returns a new KubeStorageVersionMigratorLister. +func NewKubeStorageVersionMigratorLister(indexer cache.Indexer) KubeStorageVersionMigratorLister { + return &kubeStorageVersionMigratorLister{listers.New[*operatorv1.KubeStorageVersionMigrator](indexer, operatorv1.Resource("kubestorageversionmigrator"))} +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/machineconfiguration.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/machineconfiguration.go new file mode 100644 index 0000000000..c9ef3def51 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/machineconfiguration.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "k8s.io/client-go/tools/cache" +) + +// MachineConfigurationLister helps list MachineConfigurations. +// All objects returned here must be treated as read-only. +type MachineConfigurationLister interface { + // List lists all MachineConfigurations in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*operatorv1.MachineConfiguration, err error) + // Get retrieves the MachineConfiguration from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*operatorv1.MachineConfiguration, error) + MachineConfigurationListerExpansion +} + +// machineConfigurationLister implements the MachineConfigurationLister interface. +type machineConfigurationLister struct { + listers.ResourceIndexer[*operatorv1.MachineConfiguration] +} + +// NewMachineConfigurationLister returns a new MachineConfigurationLister. +func NewMachineConfigurationLister(indexer cache.Indexer) MachineConfigurationLister { + return &machineConfigurationLister{listers.New[*operatorv1.MachineConfiguration](indexer, operatorv1.Resource("machineconfiguration"))} +} 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 0000000000..d9b678162b --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/network.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.Network, error) + NetworkListerExpansion +} + +// networkLister implements the NetworkLister interface. +type networkLister struct { + listers.ResourceIndexer[*operatorv1.Network] +} + +// NewNetworkLister returns a new NetworkLister. +func NewNetworkLister(indexer cache.Indexer) NetworkLister { + return &networkLister{listers.New[*operatorv1.Network](indexer, operatorv1.Resource("network"))} +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1/olm.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/olm.go new file mode 100644 index 0000000000..c5f6417059 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/olm.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "k8s.io/client-go/tools/cache" +) + +// OLMLister helps list OLMs. +// All objects returned here must be treated as read-only. +type OLMLister interface { + // List lists all OLMs in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*operatorv1.OLM, err error) + // Get retrieves the OLM from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*operatorv1.OLM, error) + OLMListerExpansion +} + +// oLMLister implements the OLMLister interface. +type oLMLister struct { + listers.ResourceIndexer[*operatorv1.OLM] +} + +// NewOLMLister returns a new OLMLister. +func NewOLMLister(indexer cache.Indexer) OLMLister { + return &oLMLister{listers.New[*operatorv1.OLM](indexer, operatorv1.Resource("olm"))} +} 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 0000000000..96ad171cbb --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftapiserver.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.OpenShiftAPIServer, error) + OpenShiftAPIServerListerExpansion +} + +// openShiftAPIServerLister implements the OpenShiftAPIServerLister interface. +type openShiftAPIServerLister struct { + listers.ResourceIndexer[*operatorv1.OpenShiftAPIServer] +} + +// NewOpenShiftAPIServerLister returns a new OpenShiftAPIServerLister. +func NewOpenShiftAPIServerLister(indexer cache.Indexer) OpenShiftAPIServerLister { + return &openShiftAPIServerLister{listers.New[*operatorv1.OpenShiftAPIServer](indexer, operatorv1.Resource("openshiftapiserver"))} +} 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 0000000000..66e4d9af0c --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/openshiftcontrollermanager.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.OpenShiftControllerManager, error) + OpenShiftControllerManagerListerExpansion +} + +// openShiftControllerManagerLister implements the OpenShiftControllerManagerLister interface. +type openShiftControllerManagerLister struct { + listers.ResourceIndexer[*operatorv1.OpenShiftControllerManager] +} + +// NewOpenShiftControllerManagerLister returns a new OpenShiftControllerManagerLister. +func NewOpenShiftControllerManagerLister(indexer cache.Indexer) OpenShiftControllerManagerLister { + return &openShiftControllerManagerLister{listers.New[*operatorv1.OpenShiftControllerManager](indexer, operatorv1.Resource("openshiftcontrollermanager"))} +} 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 0000000000..68e3678f69 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/serviceca.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.ServiceCA, error) + ServiceCAListerExpansion +} + +// serviceCALister implements the ServiceCALister interface. +type serviceCALister struct { + listers.ResourceIndexer[*operatorv1.ServiceCA] +} + +// NewServiceCALister returns a new ServiceCALister. +func NewServiceCALister(indexer cache.Indexer) ServiceCALister { + return &serviceCALister{listers.New[*operatorv1.ServiceCA](indexer, operatorv1.Resource("serviceca"))} +} 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 0000000000..b82d90a51d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogapiserver.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.ServiceCatalogAPIServer, error) + ServiceCatalogAPIServerListerExpansion +} + +// serviceCatalogAPIServerLister implements the ServiceCatalogAPIServerLister interface. +type serviceCatalogAPIServerLister struct { + listers.ResourceIndexer[*operatorv1.ServiceCatalogAPIServer] +} + +// NewServiceCatalogAPIServerLister returns a new ServiceCatalogAPIServerLister. +func NewServiceCatalogAPIServerLister(indexer cache.Indexer) ServiceCatalogAPIServerLister { + return &serviceCatalogAPIServerLister{listers.New[*operatorv1.ServiceCatalogAPIServer](indexer, operatorv1.Resource("servicecatalogapiserver"))} +} 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 0000000000..32c70828b9 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/servicecatalogcontrollermanager.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.ServiceCatalogControllerManager, error) + ServiceCatalogControllerManagerListerExpansion +} + +// serviceCatalogControllerManagerLister implements the ServiceCatalogControllerManagerLister interface. +type serviceCatalogControllerManagerLister struct { + listers.ResourceIndexer[*operatorv1.ServiceCatalogControllerManager] +} + +// NewServiceCatalogControllerManagerLister returns a new ServiceCatalogControllerManagerLister. +func NewServiceCatalogControllerManagerLister(indexer cache.Indexer) ServiceCatalogControllerManagerLister { + return &serviceCatalogControllerManagerLister{listers.New[*operatorv1.ServiceCatalogControllerManager](indexer, operatorv1.Resource("servicecatalogcontrollermanager"))} +} 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 0000000000..9817c3cbcc --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1/storage.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1.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) (*operatorv1.Storage, error) + StorageListerExpansion +} + +// storageLister implements the StorageLister interface. +type storageLister struct { + listers.ResourceIndexer[*operatorv1.Storage] +} + +// NewStorageLister returns a new StorageLister. +func NewStorageLister(indexer cache.Indexer) StorageLister { + return &storageLister{listers.New[*operatorv1.Storage](indexer, operatorv1.Resource("storage"))} +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/clusterversionoperator.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/clusterversionoperator.go new file mode 100644 index 0000000000..bd07dd3c41 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/clusterversionoperator.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "k8s.io/client-go/tools/cache" +) + +// ClusterVersionOperatorLister helps list ClusterVersionOperators. +// All objects returned here must be treated as read-only. +type ClusterVersionOperatorLister interface { + // List lists all ClusterVersionOperators in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*operatorv1alpha1.ClusterVersionOperator, err error) + // Get retrieves the ClusterVersionOperator from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*operatorv1alpha1.ClusterVersionOperator, error) + ClusterVersionOperatorListerExpansion +} + +// clusterVersionOperatorLister implements the ClusterVersionOperatorLister interface. +type clusterVersionOperatorLister struct { + listers.ResourceIndexer[*operatorv1alpha1.ClusterVersionOperator] +} + +// NewClusterVersionOperatorLister returns a new ClusterVersionOperatorLister. +func NewClusterVersionOperatorLister(indexer cache.Indexer) ClusterVersionOperatorLister { + return &clusterVersionOperatorLister{listers.New[*operatorv1alpha1.ClusterVersionOperator](indexer, operatorv1alpha1.Resource("clusterversionoperator"))} +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/etcdbackup.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/etcdbackup.go new file mode 100644 index 0000000000..d44cce3376 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/etcdbackup.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "k8s.io/client-go/tools/cache" +) + +// EtcdBackupLister helps list EtcdBackups. +// All objects returned here must be treated as read-only. +type EtcdBackupLister interface { + // List lists all EtcdBackups in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*operatorv1alpha1.EtcdBackup, err error) + // Get retrieves the EtcdBackup from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*operatorv1alpha1.EtcdBackup, error) + EtcdBackupListerExpansion +} + +// etcdBackupLister implements the EtcdBackupLister interface. +type etcdBackupLister struct { + listers.ResourceIndexer[*operatorv1alpha1.EtcdBackup] +} + +// NewEtcdBackupLister returns a new EtcdBackupLister. +func NewEtcdBackupLister(indexer cache.Indexer) EtcdBackupLister { + return &etcdBackupLister{listers.New[*operatorv1alpha1.EtcdBackup](indexer, operatorv1alpha1.Resource("etcdbackup"))} +} 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 0000000000..03d9d98683 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/expansion_generated.go @@ -0,0 +1,19 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +// ClusterVersionOperatorListerExpansion allows custom methods to be added to +// ClusterVersionOperatorLister. +type ClusterVersionOperatorListerExpansion interface{} + +// EtcdBackupListerExpansion allows custom methods to be added to +// EtcdBackupLister. +type EtcdBackupListerExpansion interface{} + +// ImageContentSourcePolicyListerExpansion allows custom methods to be added to +// ImageContentSourcePolicyLister. +type ImageContentSourcePolicyListerExpansion interface{} + +// OLMListerExpansion allows custom methods to be added to +// OLMLister. +type OLMListerExpansion 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 0000000000..8408ee2b28 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/imagecontentsourcepolicy.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "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 []*operatorv1alpha1.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) (*operatorv1alpha1.ImageContentSourcePolicy, error) + ImageContentSourcePolicyListerExpansion +} + +// imageContentSourcePolicyLister implements the ImageContentSourcePolicyLister interface. +type imageContentSourcePolicyLister struct { + listers.ResourceIndexer[*operatorv1alpha1.ImageContentSourcePolicy] +} + +// NewImageContentSourcePolicyLister returns a new ImageContentSourcePolicyLister. +func NewImageContentSourcePolicyLister(indexer cache.Indexer) ImageContentSourcePolicyLister { + return &imageContentSourcePolicyLister{listers.New[*operatorv1alpha1.ImageContentSourcePolicy](indexer, operatorv1alpha1.Resource("imagecontentsourcepolicy"))} +} diff --git a/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/olm.go b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/olm.go new file mode 100644 index 0000000000..0a66150651 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/listers/operator/v1alpha1/olm.go @@ -0,0 +1,32 @@ +// Code generated by lister-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + labels "k8s.io/apimachinery/pkg/labels" + listers "k8s.io/client-go/listers" + cache "k8s.io/client-go/tools/cache" +) + +// OLMLister helps list OLMs. +// All objects returned here must be treated as read-only. +type OLMLister interface { + // List lists all OLMs in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*operatorv1alpha1.OLM, err error) + // Get retrieves the OLM from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*operatorv1alpha1.OLM, error) + OLMListerExpansion +} + +// oLMLister implements the OLMLister interface. +type oLMLister struct { + listers.ResourceIndexer[*operatorv1alpha1.OLM] +} + +// NewOLMLister returns a new OLMLister. +func NewOLMLister(indexer cache.Indexer) OLMLister { + return &oLMLister{listers.New[*operatorv1alpha1.OLM](indexer, operatorv1alpha1.Resource("olm"))} +} diff --git a/vendor/modules.txt b/vendor/modules.txt index bd71ec6af9..6b0e60a4fb 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -226,6 +226,18 @@ github.com/openshift/client-go/machineconfiguration/listers/machineconfiguration github.com/openshift/client-go/machineconfiguration/listers/machineconfiguration/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/security/applyconfigurations github.com/openshift/client-go/security/applyconfigurations/internal github.com/openshift/client-go/security/applyconfigurations/security/v1