From 1e63998c9d8409f58b549ce2167f78120f4ab2d9 Mon Sep 17 00:00:00 2001 From: njhale Date: Mon, 12 Nov 2018 14:57:38 -0500 Subject: [PATCH] feat(olm): use cache listers in olm-operator --- Makefile | 3 +- go.sum | 3 + pkg/api/wrappers/deployment_install_client.go | 17 +- .../deployment_install_client_test.go | 24 +- pkg/controller/install/resolver.go | 7 +- pkg/controller/operators/olm/operator.go | 24 +- pkg/controller/operators/olm/operator_test.go | 35 +- pkg/controller/operators/olm/requirements.go | 4 +- .../operators/olm/requirements_test.go | 2 +- .../listers/fake_v1_service_account_lister.go | 190 +++++++ ...ake_v1_service_account_namespace_lister.go | 195 +++++++ pkg/fakes/fake_strategy_resolver.go | 27 +- .../customresourcedefinition.go | 55 ++ pkg/lib/operatorlister/lister.go | 47 +- .../fake_apiextensions_v1beta1lister.go | 140 +++++ .../fake_apiregistration_v1lister.go | 140 +++++ .../operatorlisterfakes/fake_apps_v1lister.go | 142 +++++ .../operatorlisterfakes/fake_core_v1lister.go | 452 ++++++++++++++++ .../fake_operator_lister.go | 485 ++++++++++++++++++ .../fake_operators_v1alpha1lister.go | 142 +++++ .../fake_operators_v1alpha2lister.go | 142 +++++ .../operatorlisterfakes/fake_rbac_v1lister.go | 450 ++++++++++++++++ pkg/metrics/metrics.go | 15 +- scripts/generate_mocks.sh | 2 + .../apiextensions/interface.go | 46 ++ .../v1beta1/customresourcedefinition.go | 88 ++++ .../apiextensions/v1beta1/interface.go | 45 ++ .../informers/externalversions/factory.go | 180 +++++++ .../informers/externalversions/generic.go | 62 +++ .../internalinterfaces/factory_interfaces.go | 38 ++ .../v1beta1/customresourcedefinition.go | 65 +++ .../v1beta1/expansion_generated.go | 23 + vendor/modules.txt | 15 +- 33 files changed, 3236 insertions(+), 69 deletions(-) create mode 100644 pkg/fakes/client-go/listers/fake_v1_service_account_lister.go create mode 100644 pkg/fakes/client-go/listers/fake_v1_service_account_namespace_lister.go create mode 100644 pkg/lib/operatorlister/customresourcedefinition.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_apiextensions_v1beta1lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_apiregistration_v1lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_apps_v1lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_core_v1lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_operator_lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha1lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha2lister.go create mode 100644 pkg/lib/operatorlister/operatorlisterfakes/fake_rbac_v1lister.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/interface.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/customresourcedefinition.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/interface.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/factory.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/generic.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/customresourcedefinition.go create mode 100644 vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/expansion_generated.go diff --git a/Makefile b/Makefile index 3eface65fd..fa2747de84 100644 --- a/Makefile +++ b/Makefile @@ -130,7 +130,8 @@ container-mockgen: docker build -t olm:mockgen -f mockgen.Dockerfile . docker run --name temp-mockgen olm:mockgen /bin/true docker cp temp-mockgen:/go/src/github.com/operator-framework/operator-lifecycle-manager/pkg/api/wrappers/wrappersfakes/. ./pkg/api/wrappers/wrappersfakes - docker cp temp-mockgen:/go/src/github.com/operator-framework/operator-lifecycle-manager/pkg/fakes/. ./pkg/fakes + docker cp temp-mockgen:/go/src/github.com/operator-framework/operator-lifecycle-manager/pkg/fakes/client-go/listers/. ./pkg/fakes/client-go/listers + docker cp temp-mockgen:/go/src/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister/operatorlisterfakes/. ./pkg/lib/operatorlister/operatorlisterfakes docker cp temp-mockgen:/go/src/github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient/mock_client.go ./pkg/lib/operatorclient/mock_client.go docker rm temp-mockgen diff --git a/go.sum b/go.sum index 4504299ee7..c1688c0eb8 100644 --- a/go.sum +++ b/go.sum @@ -214,12 +214,14 @@ k8s.io/api v0.0.0-20181108095152-eee84a6322ca h1:0gIeW03B5m7yni69Y95oPgDXv7ow7pu k8s.io/api v0.0.0-20181108095152-eee84a6322ca/go.mod h1:iuAfoD4hCxJ8Onx9kaTIt30j7jUFS00AXQi6QMi99vA= k8s.io/apiextensions-apiserver v0.0.0-20180905004947-16750353bf97 h1:s4lWWs6JN5kWVzk5bztddkr5kgO/cGIbqTDP+QttUeQ= k8s.io/apiextensions-apiserver v0.0.0-20180905004947-16750353bf97/go.mod h1:IxkesAMoaCRoLrPJdZNZUQp9NfZnzqaVzLhb2VEQzXE= +k8s.io/apiextensions-apiserver v0.0.0-20181110192823-2c43ee60e25b h1:O3KqnOdhludLAAHs7bvV7UpPYow3gqLqF5Junc5hbw8= k8s.io/apimachinery v0.0.0-20181026144827-8ee1a638bafa h1:i0EOpPFWExNx7efINILpw8LJeah7gakRl1zjvwVfjiI= k8s.io/apimachinery v0.0.0-20181026144827-8ee1a638bafa/go.mod h1:ccL7Eh7zubPUSh9A3USN90/OzHNSVN6zxzde07TDCL0= k8s.io/apiserver v0.0.0-20181026151315-13cfe3978170 h1:CqI85nZvPaV+7JFono0nAOGOx2brocqefcOhDPVhHKI= k8s.io/apiserver v0.0.0-20181026151315-13cfe3978170/go.mod h1:6bqaTSOSJavUIXUtfaR9Os9JtTCm8ZqH2SUl2S60C4w= k8s.io/client-go v8.0.0+incompatible h1:tTI4hRmb1DRMl4fG6Vclfdi6nTM82oIrTT7HfitmxC4= k8s.io/client-go v8.0.0+incompatible/go.mod h1:7vJpHMYJwNQCWgzmNV+VYUl1zCObLyodBc8nIyt8L5s= +k8s.io/client-go v9.0.0+incompatible h1:2kqW3X2xQ9SbFvWZjGEHBLlWc1LG9JIJNXWkuqwdZ3A= k8s.io/code-generator v0.0.0-20180904193909-8c97d6ab64da h1:L6YB6ObZIbZlYikTQcCjzZGilwS3OVyQBA2esULs8VM= k8s.io/code-generator v0.0.0-20180904193909-8c97d6ab64da/go.mod h1:MYiN+ZJZ9HkETbgVZdWw2AsuAi9PZ4V80cwfuf2axe8= k8s.io/gengo v0.0.0-20181106084056-51747d6e00da h1:ZMvcXtMVbhUCtCuiSEzBV+Eur4swzfdxx6ZyX3qT6dk= @@ -228,6 +230,7 @@ k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92 h1:PgoMI/L1Nu5Vmvgm+vGheLuxKST8h6 k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk= k8s.io/kube-aggregator v0.0.0-20180905000155-efa32eb095fe h1:LM48rywzVEPRg+Os2oUL9/vsztPQGoxmiD3m5VySchw= k8s.io/kube-aggregator v0.0.0-20180905000155-efa32eb095fe/go.mod h1:8sbzT4QQKDEmSCIbfqjV0sd97GpUT7A4W626sBiYJmU= +k8s.io/kube-aggregator v0.0.0-20181110192014-6f96af33cb59 h1:8VFjmCurXo3sMW0ASrUvoE4aT8FCzsIz55uic1EyUIc= k8s.io/kube-openapi v0.0.0-20181031203759-72693cb1fadd h1:ggv/Vfza0i5xuhUZyYyxcc25AmQvHY8Zi1C2m8WgBvA= k8s.io/kube-openapi v0.0.0-20181031203759-72693cb1fadd/go.mod h1:BXM9ceUBTj2QnfH2MK1odQs778ajze1RxcmP6S8RVVc= k8s.io/kubernetes v1.11.5-beta.0.0.20181108064615-3290824d1c7b h1:i9PV0cnNZrleFj2YjDYDAUku1qg/SlKfdm4LdTJzAFo= diff --git a/pkg/api/wrappers/deployment_install_client.go b/pkg/api/wrappers/deployment_install_client.go index 856d8a2058..567d8104ac 100644 --- a/pkg/api/wrappers/deployment_install_client.go +++ b/pkg/api/wrappers/deployment_install_client.go @@ -2,14 +2,16 @@ package wrappers import ( - "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" - "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" "github.com/pkg/errors" appsv1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" rbacv1 "k8s.io/api/rbac/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" ) var ErrNilObject = errors.New("Bad object supplied: ") @@ -27,14 +29,16 @@ type InstallStrategyDeploymentInterface interface { type InstallStrategyDeploymentClientForNamespace struct { opClient operatorclient.ClientInterface + opLister operatorlister.OperatorLister Namespace string } var _ InstallStrategyDeploymentInterface = &InstallStrategyDeploymentClientForNamespace{} -func NewInstallStrategyDeploymentClient(opClient operatorclient.ClientInterface, namespace string) InstallStrategyDeploymentInterface { +func NewInstallStrategyDeploymentClient(opClient operatorclient.ClientInterface, opLister operatorlister.OperatorLister, namespace string) InstallStrategyDeploymentInterface { return &InstallStrategyDeploymentClientForNamespace{ opClient: opClient, + opLister: opLister, Namespace: namespace, } } @@ -52,7 +56,7 @@ func (c *InstallStrategyDeploymentClientForNamespace) EnsureServiceAccount(servi return nil, ErrNilObject } - foundAccount, err := c.opClient.GetServiceAccount(c.Namespace, serviceAccount.Name) + foundAccount, err := c.opLister.CoreV1().ServiceAccountLister().ServiceAccounts(c.Namespace).Get(serviceAccount.Name) if err != nil && !apierrors.IsNotFound(err) { return nil, errors.Wrap(err, "checking for existing serviceacccount failed") } @@ -96,14 +100,13 @@ func (c *InstallStrategyDeploymentClientForNamespace) CreateOrUpdateDeployment(d } func (c *InstallStrategyDeploymentClientForNamespace) GetServiceAccountByName(serviceAccountName string) (*corev1.ServiceAccount, error) { - return c.opClient.KubernetesInterface().CoreV1().ServiceAccounts(c.Namespace).Get(serviceAccountName, metav1.GetOptions{}) + return c.opLister.CoreV1().ServiceAccountLister().ServiceAccounts(c.Namespace).Get(serviceAccountName) } func (c *InstallStrategyDeploymentClientForNamespace) FindAnyDeploymentsMatchingNames(depNames []string) ([]*appsv1.Deployment, error) { var deployments []*appsv1.Deployment for _, depName := range depNames { - fetchedDep, err := c.opClient.GetDeployment(c.Namespace, depName) - + fetchedDep, err := c.opLister.AppsV1().DeploymentLister().Deployments(c.Namespace).Get(depName) if err == nil { deployments = append(deployments, fetchedDep) } else { diff --git a/pkg/api/wrappers/deployment_install_client_test.go b/pkg/api/wrappers/deployment_install_client_test.go index d4169845c7..2266a6a708 100644 --- a/pkg/api/wrappers/deployment_install_client_test.go +++ b/pkg/api/wrappers/deployment_install_client_test.go @@ -3,10 +3,9 @@ package wrappers import ( "fmt" "testing" + "time" "github.com/golang/mock/gomock" - "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha1" - "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" "github.com/pkg/errors" "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" @@ -14,11 +13,17 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/diff" + + listerfakes "github.com/operator-framework/operator-lifecycle-manager/pkg/fakes/client-go/listers" + "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha1" + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister/operatorlisterfakes" ) var ( Controller = false BlockOwnerDeletion = false + WakeupInterval = 5 * time.Second ) func ownerReferenceFromCSV(csv *v1alpha1.ClusterServiceVersion) metav1.OwnerReference { @@ -405,13 +410,18 @@ func TestEnsureServiceAccount(t *testing.T) { t.Run(testName, func(t *testing.T) { ctrl := gomock.NewController(t) mockOpClient := operatorclient.NewMockClientInterface(ctrl) - client := NewInstallStrategyDeploymentClient(mockOpClient, tt.state.namespace) + fakeLister := &operatorlisterfakes.FakeOperatorLister{} + fakeCoreV1Lister := &operatorlisterfakes.FakeCoreV1Lister{} + fakeServiceAccountLister := &listerfakes.FakeServiceAccountLister{} + fakeServiceAccountNamespacedLister := &listerfakes.FakeServiceAccountNamespaceLister{} + fakeServiceAccountNamespacedLister.GetReturns(tt.state.existingServiceAccount, tt.state.getServiceAccountError) + fakeServiceAccountLister.ServiceAccountsReturns(fakeServiceAccountNamespacedLister) + fakeCoreV1Lister.ServiceAccountListerReturns(fakeServiceAccountLister) + fakeLister.CoreV1Returns(fakeCoreV1Lister) - mockOpClient.EXPECT(). - GetServiceAccount(tt.state.namespace, tt.input.serviceAccountName). - Return(tt.state.existingServiceAccount, tt.state.getServiceAccountError). - AnyTimes() + client := NewInstallStrategyDeploymentClient(mockOpClient, fakeLister, tt.state.namespace) + mockOpClient.EXPECT(). CreateServiceAccount(tt.input.serviceAccount). Return(tt.state.createServiceAccountResult, tt.state.createServiceAccountError). diff --git a/pkg/controller/install/resolver.go b/pkg/controller/install/resolver.go index 3f090a5d8f..c74b522651 100644 --- a/pkg/controller/install/resolver.go +++ b/pkg/controller/install/resolver.go @@ -10,6 +10,7 @@ import ( "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/wrappers" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" + "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" ) @@ -24,7 +25,7 @@ type StrategyInstaller interface { type StrategyResolverInterface interface { UnmarshalStrategy(s v1alpha1.NamedInstallStrategy) (strategy Strategy, err error) - InstallerForStrategy(strategyName string, opClient operatorclient.ClientInterface, owner ownerutil.Owner, previousStrategy Strategy) StrategyInstaller + InstallerForStrategy(strategyName string, opClient operatorclient.ClientInterface, opLister operatorlister.OperatorLister, owner ownerutil.Owner, previousStrategy Strategy) StrategyInstaller } type StrategyResolver struct{} @@ -42,10 +43,10 @@ func (r *StrategyResolver) UnmarshalStrategy(s v1alpha1.NamedInstallStrategy) (s return } -func (r *StrategyResolver) InstallerForStrategy(strategyName string, opClient operatorclient.ClientInterface, owner ownerutil.Owner, previousStrategy Strategy) StrategyInstaller { +func (r *StrategyResolver) InstallerForStrategy(strategyName string, opClient operatorclient.ClientInterface, opLister operatorlister.OperatorLister, owner ownerutil.Owner, previousStrategy Strategy) StrategyInstaller { switch strategyName { case InstallStrategyNameDeployment: - strategyClient := wrappers.NewInstallStrategyDeploymentClient(opClient, owner.GetNamespace()) + strategyClient := wrappers.NewInstallStrategyDeploymentClient(opClient, opLister, owner.GetNamespace()) return NewStrategyDeploymentInstaller(strategyClient, owner, previousStrategy) } diff --git a/pkg/controller/operators/olm/operator.go b/pkg/controller/operators/olm/operator.go index 7e0f5eef44..f55a899a57 100644 --- a/pkg/controller/operators/olm/operator.go +++ b/pkg/controller/operators/olm/operator.go @@ -19,6 +19,7 @@ import ( "k8s.io/client-go/tools/record" "k8s.io/client-go/util/workqueue" kagg "k8s.io/kube-aggregator/pkg/client/informers/externalversions" + aextv1beta1 "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned" @@ -145,7 +146,7 @@ func NewOperator(crClient versioned.Interface, opClient operatorclient.ClientInt op.RegisterQueueInformer(namespaceQueueInformer) op.lister.CoreV1().RegisterNamespaceLister(namespaceInformer.Lister()) - // Register APIService QueueInformers + // Register APIService QueueInformer apiServiceInformer := kagg.NewSharedInformerFactory(opClient.ApiregistrationV1Interface(), wakeupInterval).Apiregistration().V1().APIServices() op.RegisterQueueInformer(queueinformer.NewInformer( workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "apiservices"), @@ -158,6 +159,20 @@ func NewOperator(crClient versioned.Interface, opClient operatorclient.ClientInt metrics.NewMetricsNil(), )) op.lister.APIRegistrationV1().RegisterAPIServiceLister(apiServiceInformer.Lister()) + + // Register CustomResourceDefinition QueueInformer + customResourceDefinitionInformer := aextv1beta1.NewSharedInformerFactory(opClient.ApiextensionsV1beta1Interface(), wakeupInterval).Apiextensions().V1beta1().CustomResourceDefinitions() + op.RegisterQueueInformer(queueinformer.NewInformer( + workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "customresourcedefinitions"), + customResourceDefinitionInformer.Informer(), + op.syncObject, + &cache.ResourceEventHandlerFuncs{ + DeleteFunc: op.handleDeletion, + }, + "customresourcedefinitions", + metrics.NewMetricsNil(), + )) + op.lister.APIExtensionsV1beta1().RegisterCustomResourceDefinitionLister(customResourceDefinitionInformer.Lister()) // Register Secret QueueInformer secretInformer := informers.NewSharedInformerFactory(opClient.KubernetesInterface(), wakeupInterval).Core().V1().Secrets() @@ -214,7 +229,7 @@ func NewOperator(crClient versioned.Interface, opClient operatorclient.ClientInt // Register queue and QueueInformer queueName := fmt.Sprintf("%s/clusterserviceversions", namespace) csvQueue := workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), queueName) - csvQueueInformer := queueinformer.NewInformer(csvQueue, csvInformer.Informer(), op.syncClusterServiceVersion, csvHandlers, queueName, metrics.NewMetricsCSV(op.client)) + csvQueueInformer := queueinformer.NewInformer(csvQueue, csvInformer.Informer(), op.syncClusterServiceVersion, csvHandlers, queueName, metrics.NewMetricsCSV(op.lister.OperatorsV1alpha1().ClusterServiceVersionLister())) op.RegisterQueueInformer(csvQueueInformer) op.csvQueues[namespace] = csvQueue } @@ -592,6 +607,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v for _, csv := range a.findIntermediatesForDeletion(out) { // we only mark them in this step, in case some get deleted but others fail and break the replacement chain csv.SetPhaseWithEvent(v1alpha1.CSVPhaseDeleting, v1alpha1.CSVReasonReplaced, "has been replaced by a newer ClusterServiceVersion that has successfully installed.", a.recorder) + // ignore errors and success here; this step is just an optimization to speed up GC a.client.OperatorsV1alpha1().ClusterServiceVersions(csv.GetNamespace()).UpdateStatus(csv) a.requeueCSV(csv.GetName(), csv.GetNamespace()) @@ -726,7 +742,7 @@ func (a *Operator) parseStrategiesAndUpdateStatus(csv *v1alpha1.ClusterServiceVe } strName := strategy.GetStrategyName() - installer := a.resolver.InstallerForStrategy(strName, a.OpClient, csv, previousStrategy) + installer := a.resolver.InstallerForStrategy(strName, a.OpClient, a.lister, csv, previousStrategy) return installer, strategy, previousStrategy } @@ -790,7 +806,7 @@ func (a *Operator) isReplacing(in *v1alpha1.ClusterServiceVersion) *v1alpha1.Clu if in.Spec.Replaces == "" { return nil } - previous, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(in.GetNamespace()).Get(in.Spec.Replaces, metav1.GetOptions{}) + previous, err := a.lister.OperatorsV1alpha1().ClusterServiceVersionLister().ClusterServiceVersions(in.GetNamespace()).Get(in.Spec.Replaces) if err != nil { log.Debugf("unable to get previous csv: %s", err.Error()) return nil diff --git a/pkg/controller/operators/olm/operator_test.go b/pkg/controller/operators/olm/operator_test.go index 746657c3c5..1ff9b4a438 100644 --- a/pkg/controller/operators/olm/operator_test.go +++ b/pkg/controller/operators/olm/operator_test.go @@ -32,6 +32,8 @@ import ( "k8s.io/client-go/util/workqueue" apiregistrationv1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1" apiregistrationfake "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/fake" + kagg "k8s.io/kube-aggregator/pkg/client/informers/externalversions" + aextv1beta1 "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha1" "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha2" @@ -44,7 +46,6 @@ import ( "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/queueinformer" - kagg "k8s.io/kube-aggregator/pkg/client/informers/externalversions" ) // Fakes @@ -118,7 +119,7 @@ func apiResourcesForObjects(objs []runtime.Object) []*metav1.APIResourceList { } // NewFakeOperator creates a new operator using fake clients -func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extObjs []runtime.Object, regObjs []runtime.Object, resolver install.StrategyResolverInterface, namespaces []string, stopCh <-chan struct{}) (*Operator, error) { +func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extObjs []runtime.Object, regObjs []runtime.Object, resolver install.StrategyResolverInterface, namespaces []string, stopCh <-chan struct{}) (*Operator, []cache.InformerSynced, error) { // Create client fakes clientFake := fake.NewSimpleClientset(clientObjs...) k8sClientFake := k8sfake.NewSimpleClientset(k8sObjs...) @@ -127,7 +128,7 @@ func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extO eventRecorder, err := event.NewRecorder(opClientFake.KubernetesInterface().CoreV1().Events(metav1.NamespaceAll)) if err != nil { - return nil, err + return nil, nil, err } // Create the new operator @@ -141,7 +142,7 @@ func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extO recorder: eventRecorder, } - wakeupInterval := 5 * time.Second + wakeupInterval := 5 * time.Minute informerFactory := informers.NewSharedInformerFactory(opClientFake.KubernetesInterface(), wakeupInterval) roleInformer := informerFactory.Rbac().V1().Roles() @@ -153,7 +154,8 @@ func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extO serviceAccountInformer := informerFactory.Core().V1().ServiceAccounts() namespaceInformer := informerFactory.Core().V1().Namespaces() apiServiceInformer := kagg.NewSharedInformerFactory(opClientFake.ApiregistrationV1Interface(), wakeupInterval).Apiregistration().V1().APIServices() - + customResourceDefinitionInformer := aextv1beta1.NewSharedInformerFactory(opClientFake.ApiextensionsV1beta1Interface(), wakeupInterval).Apiextensions().V1beta1().CustomResourceDefinitions() + // Register informers informerList := []cache.SharedIndexInformer{ roleInformer.Informer(), @@ -165,6 +167,7 @@ func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extO serviceAccountInformer.Informer(), namespaceInformer.Informer(), apiServiceInformer.Informer(), + customResourceDefinitionInformer.Informer(), } for _, ns := range namespaces { @@ -187,6 +190,7 @@ func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extO op.lister.CoreV1().RegisterServiceAccountLister(metav1.NamespaceAll, serviceAccountInformer.Lister()) op.lister.CoreV1().RegisterNamespaceLister(namespaceInformer.Lister()) op.lister.APIRegistrationV1().RegisterAPIServiceLister(apiServiceInformer.Lister()) + op.lister.APIExtensionsV1beta1().RegisterCustomResourceDefinitionLister(customResourceDefinitionInformer.Lister()) var hasSyncedCheckFns []cache.InformerSynced for _, informer := range informerList { @@ -196,10 +200,10 @@ func NewFakeOperator(clientObjs []runtime.Object, k8sObjs []runtime.Object, extO } if ok := cache.WaitForCacheSync(stopCh, hasSyncedCheckFns...); !ok { - return nil, fmt.Errorf("failed to wait for caches to sync") + return nil, nil, fmt.Errorf("failed to wait for caches to sync") } - return op, nil + return op, hasSyncedCheckFns, nil } func (o *Operator) GetClient() versioned.Interface { @@ -2031,7 +2035,7 @@ func TestTransitionCSV(t *testing.T) { tt.initial.objs = append(tt.initial.objs, namespaceObj) stopCh := make(chan struct{}) defer func() { stopCh <- struct{}{} }() - op, err := NewFakeOperator(tt.initial.csvs, tt.initial.objs, tt.initial.crds, tt.initial.apis, &install.StrategyResolver{}, []string{namespace}, stopCh) + op, hasSyncedFns, err := NewFakeOperator(tt.initial.csvs, tt.initial.objs, tt.initial.crds, tt.initial.apis, &install.StrategyResolver{}, []string{namespace}, stopCh) require.NoError(t, err) // run csv sync for each CSV @@ -2039,6 +2043,10 @@ func TestTransitionCSV(t *testing.T) { err := op.syncClusterServiceVersion(csv) expectedErr := tt.expected.err[csv.(*v1alpha1.ClusterServiceVersion).Name] require.Equal(t, expectedErr, err) + + // wait for informers to sync before continuing + ok := cache.WaitForCacheSync(stopCh, hasSyncedFns...) + require.True(t, ok, "wait for cache sync failed") } // get csvs in the cluster @@ -2279,7 +2287,7 @@ func TestSyncOperatorGroups(t *testing.T) { stopCh := make(chan struct{}) defer func() { stopCh <- struct{}{} }() - op, err := NewFakeOperator(tt.initial.clientObjs, tt.initial.k8sObjs, tt.initial.crds, tt.initial.apis, &install.StrategyResolver{}, namespaces, stopCh) + op, _, err := NewFakeOperator(tt.initial.clientObjs, tt.initial.k8sObjs, tt.initial.crds, tt.initial.apis, &install.StrategyResolver{}, namespaces, stopCh) require.NoError(t, err) err = op.syncOperatorGroups(tt.initial.operatorGroup) @@ -2364,11 +2372,10 @@ func TestIsReplacing(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // configure cluster state - clientFake := fake.NewSimpleClientset(tt.initial.csvs...) - - op := &Operator{ - client: clientFake, - } + stopCh := make(chan struct{}) + defer func() { stopCh <- struct{}{} }() + op, _, err := NewFakeOperator(tt.initial.csvs, nil, nil, nil, &install.StrategyResolver{}, []string{namespace}, stopCh) + require.NoError(t, err) require.Equal(t, tt.expected, op.isReplacing(tt.in)) }) diff --git a/pkg/controller/operators/olm/requirements.go b/pkg/controller/operators/olm/requirements.go index cc8254ad27..eab69b5389 100644 --- a/pkg/controller/operators/olm/requirements.go +++ b/pkg/controller/operators/olm/requirements.go @@ -26,7 +26,7 @@ func (a *Operator) requirementStatus(strategyDetailsDeployment *install.Strategy } // check if CRD exists - this verifies group, version, and kind, so no need for GVK check via discovery - crd, err := a.OpClient.ApiextensionsV1beta1Interface().ApiextensionsV1beta1().CustomResourceDefinitions().Get(r.Name, metav1.GetOptions{}) + crd, err := a.lister.APIExtensionsV1beta1().CustomResourceDefinitionLister().Get(r.Name) if err != nil { status.Status = v1alpha1.RequirementStatusReasonNotPresent met = false @@ -80,7 +80,7 @@ func (a *Operator) requirementStatus(strategyDetailsDeployment *install.Strategy } // Check if APIService is registered - apiService, err := a.OpClient.ApiregistrationV1Interface().ApiregistrationV1().APIServices().Get(name, metav1.GetOptions{}) + apiService, err := a.lister.APIRegistrationV1().APIServiceLister().Get(name) if err != nil { status.Status = "NotPresent" met = false diff --git a/pkg/controller/operators/olm/requirements_test.go b/pkg/controller/operators/olm/requirements_test.go index fc732f8058..2a38edc17a 100644 --- a/pkg/controller/operators/olm/requirements_test.go +++ b/pkg/controller/operators/olm/requirements_test.go @@ -465,7 +465,7 @@ func TestRequirementAndPermissionStatus(t *testing.T) { test.existingObjs = append(test.existingObjs, namespaceObj) stopCh := make(chan struct{}) defer func() { stopCh <- struct{}{} }() - op, err := NewFakeOperator([]runtime.Object{test.csv}, test.existingObjs, test.existingExtObjs, nil, &install.StrategyResolver{}, []string{namespace}, stopCh) + op, _, err := NewFakeOperator([]runtime.Object{test.csv}, test.existingObjs, test.existingExtObjs, nil, &install.StrategyResolver{}, []string{namespace}, stopCh) require.NoError(t, err) // Get the permission status diff --git a/pkg/fakes/client-go/listers/fake_v1_service_account_lister.go b/pkg/fakes/client-go/listers/fake_v1_service_account_lister.go new file mode 100644 index 0000000000..1593d87f6f --- /dev/null +++ b/pkg/fakes/client-go/listers/fake_v1_service_account_lister.go @@ -0,0 +1,190 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package listers + +import ( + sync "sync" + + v1 "k8s.io/api/core/v1" + labels "k8s.io/apimachinery/pkg/labels" + v1a "k8s.io/client-go/listers/core/v1" +) + +type FakeServiceAccountLister struct { + ListStub func(labels.Selector) ([]*v1.ServiceAccount, error) + listMutex sync.RWMutex + listArgsForCall []struct { + arg1 labels.Selector + } + listReturns struct { + result1 []*v1.ServiceAccount + result2 error + } + listReturnsOnCall map[int]struct { + result1 []*v1.ServiceAccount + result2 error + } + ServiceAccountsStub func(string) v1a.ServiceAccountNamespaceLister + serviceAccountsMutex sync.RWMutex + serviceAccountsArgsForCall []struct { + arg1 string + } + serviceAccountsReturns struct { + result1 v1a.ServiceAccountNamespaceLister + } + serviceAccountsReturnsOnCall map[int]struct { + result1 v1a.ServiceAccountNamespaceLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeServiceAccountLister) List(arg1 labels.Selector) ([]*v1.ServiceAccount, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + arg1 labels.Selector + }{arg1}) + fake.recordInvocation("List", []interface{}{arg1}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.listReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeServiceAccountLister) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeServiceAccountLister) ListCalls(stub func(labels.Selector) ([]*v1.ServiceAccount, error)) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = stub +} + +func (fake *FakeServiceAccountLister) ListArgsForCall(i int) labels.Selector { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + argsForCall := fake.listArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeServiceAccountLister) ListReturns(result1 []*v1.ServiceAccount, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + fake.listReturns = struct { + result1 []*v1.ServiceAccount + result2 error + }{result1, result2} +} + +func (fake *FakeServiceAccountLister) ListReturnsOnCall(i int, result1 []*v1.ServiceAccount, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 []*v1.ServiceAccount + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 []*v1.ServiceAccount + result2 error + }{result1, result2} +} + +func (fake *FakeServiceAccountLister) ServiceAccounts(arg1 string) v1a.ServiceAccountNamespaceLister { + fake.serviceAccountsMutex.Lock() + ret, specificReturn := fake.serviceAccountsReturnsOnCall[len(fake.serviceAccountsArgsForCall)] + fake.serviceAccountsArgsForCall = append(fake.serviceAccountsArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("ServiceAccounts", []interface{}{arg1}) + fake.serviceAccountsMutex.Unlock() + if fake.ServiceAccountsStub != nil { + return fake.ServiceAccountsStub(arg1) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.serviceAccountsReturns + return fakeReturns.result1 +} + +func (fake *FakeServiceAccountLister) ServiceAccountsCallCount() int { + fake.serviceAccountsMutex.RLock() + defer fake.serviceAccountsMutex.RUnlock() + return len(fake.serviceAccountsArgsForCall) +} + +func (fake *FakeServiceAccountLister) ServiceAccountsCalls(stub func(string) v1a.ServiceAccountNamespaceLister) { + fake.serviceAccountsMutex.Lock() + defer fake.serviceAccountsMutex.Unlock() + fake.ServiceAccountsStub = stub +} + +func (fake *FakeServiceAccountLister) ServiceAccountsArgsForCall(i int) string { + fake.serviceAccountsMutex.RLock() + defer fake.serviceAccountsMutex.RUnlock() + argsForCall := fake.serviceAccountsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeServiceAccountLister) ServiceAccountsReturns(result1 v1a.ServiceAccountNamespaceLister) { + fake.serviceAccountsMutex.Lock() + defer fake.serviceAccountsMutex.Unlock() + fake.ServiceAccountsStub = nil + fake.serviceAccountsReturns = struct { + result1 v1a.ServiceAccountNamespaceLister + }{result1} +} + +func (fake *FakeServiceAccountLister) ServiceAccountsReturnsOnCall(i int, result1 v1a.ServiceAccountNamespaceLister) { + fake.serviceAccountsMutex.Lock() + defer fake.serviceAccountsMutex.Unlock() + fake.ServiceAccountsStub = nil + if fake.serviceAccountsReturnsOnCall == nil { + fake.serviceAccountsReturnsOnCall = make(map[int]struct { + result1 v1a.ServiceAccountNamespaceLister + }) + } + fake.serviceAccountsReturnsOnCall[i] = struct { + result1 v1a.ServiceAccountNamespaceLister + }{result1} +} + +func (fake *FakeServiceAccountLister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + fake.serviceAccountsMutex.RLock() + defer fake.serviceAccountsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeServiceAccountLister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ v1a.ServiceAccountLister = new(FakeServiceAccountLister) diff --git a/pkg/fakes/client-go/listers/fake_v1_service_account_namespace_lister.go b/pkg/fakes/client-go/listers/fake_v1_service_account_namespace_lister.go new file mode 100644 index 0000000000..0f8561a5a1 --- /dev/null +++ b/pkg/fakes/client-go/listers/fake_v1_service_account_namespace_lister.go @@ -0,0 +1,195 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package listers + +import ( + sync "sync" + + v1 "k8s.io/api/core/v1" + labels "k8s.io/apimachinery/pkg/labels" + v1a "k8s.io/client-go/listers/core/v1" +) + +type FakeServiceAccountNamespaceLister struct { + GetStub func(string) (*v1.ServiceAccount, error) + getMutex sync.RWMutex + getArgsForCall []struct { + arg1 string + } + getReturns struct { + result1 *v1.ServiceAccount + result2 error + } + getReturnsOnCall map[int]struct { + result1 *v1.ServiceAccount + result2 error + } + ListStub func(labels.Selector) ([]*v1.ServiceAccount, error) + listMutex sync.RWMutex + listArgsForCall []struct { + arg1 labels.Selector + } + listReturns struct { + result1 []*v1.ServiceAccount + result2 error + } + listReturnsOnCall map[int]struct { + result1 []*v1.ServiceAccount + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeServiceAccountNamespaceLister) Get(arg1 string) (*v1.ServiceAccount, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("Get", []interface{}{arg1}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeServiceAccountNamespaceLister) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeServiceAccountNamespaceLister) GetCalls(stub func(string) (*v1.ServiceAccount, error)) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = stub +} + +func (fake *FakeServiceAccountNamespaceLister) GetArgsForCall(i int) string { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + argsForCall := fake.getArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeServiceAccountNamespaceLister) GetReturns(result1 *v1.ServiceAccount, result2 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + fake.getReturns = struct { + result1 *v1.ServiceAccount + result2 error + }{result1, result2} +} + +func (fake *FakeServiceAccountNamespaceLister) GetReturnsOnCall(i int, result1 *v1.ServiceAccount, result2 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 *v1.ServiceAccount + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 *v1.ServiceAccount + result2 error + }{result1, result2} +} + +func (fake *FakeServiceAccountNamespaceLister) List(arg1 labels.Selector) ([]*v1.ServiceAccount, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + arg1 labels.Selector + }{arg1}) + fake.recordInvocation("List", []interface{}{arg1}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.listReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeServiceAccountNamespaceLister) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeServiceAccountNamespaceLister) ListCalls(stub func(labels.Selector) ([]*v1.ServiceAccount, error)) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = stub +} + +func (fake *FakeServiceAccountNamespaceLister) ListArgsForCall(i int) labels.Selector { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + argsForCall := fake.listArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeServiceAccountNamespaceLister) ListReturns(result1 []*v1.ServiceAccount, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + fake.listReturns = struct { + result1 []*v1.ServiceAccount + result2 error + }{result1, result2} +} + +func (fake *FakeServiceAccountNamespaceLister) ListReturnsOnCall(i int, result1 []*v1.ServiceAccount, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 []*v1.ServiceAccount + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 []*v1.ServiceAccount + result2 error + }{result1, result2} +} + +func (fake *FakeServiceAccountNamespaceLister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeServiceAccountNamespaceLister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ v1a.ServiceAccountNamespaceLister = new(FakeServiceAccountNamespaceLister) diff --git a/pkg/fakes/fake_strategy_resolver.go b/pkg/fakes/fake_strategy_resolver.go index cd8b1a5d42..e6a41af33f 100644 --- a/pkg/fakes/fake_strategy_resolver.go +++ b/pkg/fakes/fake_strategy_resolver.go @@ -7,17 +7,19 @@ import ( v1alpha1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/apis/operators/v1alpha1" install "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install" operatorclient "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorclient" + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" ownerutil "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/ownerutil" ) type FakeStrategyResolverInterface struct { - InstallerForStrategyStub func(string, operatorclient.ClientInterface, ownerutil.Owner, install.Strategy) install.StrategyInstaller + InstallerForStrategyStub func(string, operatorclient.ClientInterface, operatorlister.OperatorLister, ownerutil.Owner, install.Strategy) install.StrategyInstaller installerForStrategyMutex sync.RWMutex installerForStrategyArgsForCall []struct { arg1 string arg2 operatorclient.ClientInterface - arg3 ownerutil.Owner - arg4 install.Strategy + arg3 operatorlister.OperatorLister + arg4 ownerutil.Owner + arg5 install.Strategy } installerForStrategyReturns struct { result1 install.StrategyInstaller @@ -42,19 +44,20 @@ type FakeStrategyResolverInterface struct { invocationsMutex sync.RWMutex } -func (fake *FakeStrategyResolverInterface) InstallerForStrategy(arg1 string, arg2 operatorclient.ClientInterface, arg3 ownerutil.Owner, arg4 install.Strategy) install.StrategyInstaller { +func (fake *FakeStrategyResolverInterface) InstallerForStrategy(arg1 string, arg2 operatorclient.ClientInterface, arg3 operatorlister.OperatorLister, arg4 ownerutil.Owner, arg5 install.Strategy) install.StrategyInstaller { fake.installerForStrategyMutex.Lock() ret, specificReturn := fake.installerForStrategyReturnsOnCall[len(fake.installerForStrategyArgsForCall)] fake.installerForStrategyArgsForCall = append(fake.installerForStrategyArgsForCall, struct { arg1 string arg2 operatorclient.ClientInterface - arg3 ownerutil.Owner - arg4 install.Strategy - }{arg1, arg2, arg3, arg4}) - fake.recordInvocation("InstallerForStrategy", []interface{}{arg1, arg2, arg3, arg4}) + arg3 operatorlister.OperatorLister + arg4 ownerutil.Owner + arg5 install.Strategy + }{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("InstallerForStrategy", []interface{}{arg1, arg2, arg3, arg4, arg5}) fake.installerForStrategyMutex.Unlock() if fake.InstallerForStrategyStub != nil { - return fake.InstallerForStrategyStub(arg1, arg2, arg3, arg4) + return fake.InstallerForStrategyStub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 @@ -69,17 +72,17 @@ func (fake *FakeStrategyResolverInterface) InstallerForStrategyCallCount() int { return len(fake.installerForStrategyArgsForCall) } -func (fake *FakeStrategyResolverInterface) InstallerForStrategyCalls(stub func(string, operatorclient.ClientInterface, ownerutil.Owner, install.Strategy) install.StrategyInstaller) { +func (fake *FakeStrategyResolverInterface) InstallerForStrategyCalls(stub func(string, operatorclient.ClientInterface, operatorlister.OperatorLister, ownerutil.Owner, install.Strategy) install.StrategyInstaller) { fake.installerForStrategyMutex.Lock() defer fake.installerForStrategyMutex.Unlock() fake.InstallerForStrategyStub = stub } -func (fake *FakeStrategyResolverInterface) InstallerForStrategyArgsForCall(i int) (string, operatorclient.ClientInterface, ownerutil.Owner, install.Strategy) { +func (fake *FakeStrategyResolverInterface) InstallerForStrategyArgsForCall(i int) (string, operatorclient.ClientInterface, operatorlister.OperatorLister, ownerutil.Owner, install.Strategy) { fake.installerForStrategyMutex.RLock() defer fake.installerForStrategyMutex.RUnlock() argsForCall := fake.installerForStrategyArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 } func (fake *FakeStrategyResolverInterface) InstallerForStrategyReturns(result1 install.StrategyInstaller) { diff --git a/pkg/lib/operatorlister/customresourcedefinition.go b/pkg/lib/operatorlister/customresourcedefinition.go new file mode 100644 index 0000000000..9bbc6ce192 --- /dev/null +++ b/pkg/lib/operatorlister/customresourcedefinition.go @@ -0,0 +1,55 @@ +package operatorlister + +import ( + "fmt" + "sync" + + v1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" + aextv1beta1 "k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1" + "k8s.io/apimachinery/pkg/labels" +) + +// UnionCustomResourceDefinitionLister is a custom implementation of an CustomResourceDefinition lister that allows a new +// Lister to be registered on the fly +type UnionCustomResourceDefinitionLister struct { + CustomResourceDefinitionLister aextv1beta1.CustomResourceDefinitionLister + CustomResourceDefinitionLock sync.RWMutex +} + +// List lists all CustomResourceDefinitions in the indexer. +func (ucl *UnionCustomResourceDefinitionLister) List(selector labels.Selector) (ret []*v1beta1.CustomResourceDefinition, err error) { + ucl.CustomResourceDefinitionLock.RLock() + defer ucl.CustomResourceDefinitionLock.RUnlock() + + if ucl.CustomResourceDefinitionLister == nil { + return nil, fmt.Errorf("no CustomResourceDefinition lister registered") + } + return ucl.CustomResourceDefinitionLister.List(selector) +} + +// Get retrieves the CustomResourceDefinition with the given name +func (ucl *UnionCustomResourceDefinitionLister) Get(name string) (*v1beta1.CustomResourceDefinition, error) { + ucl.CustomResourceDefinitionLock.RLock() + defer ucl.CustomResourceDefinitionLock.RUnlock() + + if ucl.CustomResourceDefinitionLister == nil { + return nil, fmt.Errorf("no CustomResourceDefinition lister registered") + } + return ucl.CustomResourceDefinitionLister.Get(name) +} + +// RegisterCustomResourceDefinitionLister registers a new CustomResourceDefinitionLister +func (ucl *UnionCustomResourceDefinitionLister) RegisterCustomResourceDefinitionLister(lister aextv1beta1.CustomResourceDefinitionLister) { + ucl.CustomResourceDefinitionLock.Lock() + defer ucl.CustomResourceDefinitionLock.Unlock() + + ucl.CustomResourceDefinitionLister = lister +} + +func (l *apiExtensionsV1beta1Lister) RegisterCustomResourceDefinitionLister(lister aextv1beta1.CustomResourceDefinitionLister) { + l.customResourceDefinitionLister.RegisterCustomResourceDefinitionLister(lister) +} + +func (l *apiExtensionsV1beta1Lister) CustomResourceDefinitionLister() aextv1beta1.CustomResourceDefinitionLister { + return l.customResourceDefinitionLister +} diff --git a/pkg/lib/operatorlister/lister.go b/pkg/lib/operatorlister/lister.go index ee6fbcd3eb..b4f6614846 100644 --- a/pkg/lib/operatorlister/lister.go +++ b/pkg/lib/operatorlister/lister.go @@ -1,31 +1,37 @@ package operatorlister import ( - "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" - "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha2" + aextv1beta1 "k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1" appsv1 "k8s.io/client-go/listers/apps/v1" corev1 "k8s.io/client-go/listers/core/v1" rbacv1 "k8s.io/client-go/listers/rbac/v1" aregv1 "k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1" + + "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" + "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha2" ) // OperatorLister is a union of versioned informer listers +//go:generate counterfeiter . OperatorLister type OperatorLister interface { AppsV1() AppsV1Lister CoreV1() CoreV1Lister RbacV1() RbacV1Lister APIRegistrationV1() APIRegistrationV1Lister + APIExtensionsV1beta1() APIExtensionsV1beta1Lister OperatorsV1alpha1() OperatorsV1alpha1Lister OperatorsV1alpha2() OperatorsV1alpha2Lister } +//go:generate counterfeiter . AppsV1Lister type AppsV1Lister interface { DeploymentLister() appsv1.DeploymentLister RegisterDeploymentLister(namespace string, lister appsv1.DeploymentLister) } +//go:generate counterfeiter . CoreV1Lister type CoreV1Lister interface { RegisterSecretLister(namespace string, lister corev1.SecretLister) RegisterServiceLister(namespace string, lister corev1.ServiceLister) @@ -38,6 +44,7 @@ type CoreV1Lister interface { NamespaceLister() corev1.NamespaceLister } +//go:generate counterfeiter . RbacV1Lister type RbacV1Lister interface { RegisterClusterRoleLister(lister rbacv1.ClusterRoleLister) RegisterClusterRoleBindingLister(lister rbacv1.ClusterRoleBindingLister) @@ -50,18 +57,28 @@ type RbacV1Lister interface { RoleBindingLister() rbacv1.RoleBindingLister } +//go:generate counterfeiter . APIRegistrationV1Lister type APIRegistrationV1Lister interface { RegisterAPIServiceLister(lister aregv1.APIServiceLister) APIServiceLister() aregv1.APIServiceLister } +//go:generate counterfeiter . APIExtensionsV1beta1Lister +type APIExtensionsV1beta1Lister interface { + RegisterCustomResourceDefinitionLister(lister aextv1beta1.CustomResourceDefinitionLister) + + CustomResourceDefinitionLister() aextv1beta1.CustomResourceDefinitionLister +} + +//go:generate counterfeiter . OperatorsV1alpha1Lister type OperatorsV1alpha1Lister interface { RegisterClusterServiceVersionLister(namespace string, lister v1alpha1.ClusterServiceVersionLister) ClusterServiceVersionLister() v1alpha1.ClusterServiceVersionLister } +//go:generate counterfeiter . OperatorsV1alpha2Lister type OperatorsV1alpha2Lister interface { RegisterOperatorGroupLister(namespace string, lister v1alpha2.OperatorGroupLister) @@ -120,6 +137,16 @@ func newAPIRegistrationV1Lister() *apiRegistrationV1Lister { } } +type apiExtensionsV1beta1Lister struct { + customResourceDefinitionLister *UnionCustomResourceDefinitionLister +} + +func newAPIExtensionsV1beta1Lister() *apiExtensionsV1beta1Lister { + return &apiExtensionsV1beta1Lister{ + customResourceDefinitionLister: &UnionCustomResourceDefinitionLister{}, + } +} + type operatorsV1alpha1Lister struct { clusterServiceVersionLister *UnionClusterServiceVersionLister } @@ -144,10 +171,11 @@ func newOperatorsV1alpha2Lister() *operatorsV1alpha2Lister { var _ OperatorLister = &lister{} type lister struct { - appsV1Lister *appsV1Lister - coreV1Lister *coreV1Lister - rbacV1Lister *rbacV1Lister - apiRegistrationV1Lister *apiRegistrationV1Lister + appsV1Lister *appsV1Lister + coreV1Lister *coreV1Lister + rbacV1Lister *rbacV1Lister + apiRegistrationV1Lister *apiRegistrationV1Lister + apiExtensionsV1beta1Lister *apiExtensionsV1beta1Lister operatorsV1alpha1Lister *operatorsV1alpha1Lister operatorsV1alpha2Lister *operatorsV1alpha2Lister @@ -169,6 +197,10 @@ func (l *lister) APIRegistrationV1() APIRegistrationV1Lister { return l.apiRegistrationV1Lister } +func (l *lister) APIExtensionsV1beta1() APIExtensionsV1beta1Lister { + return l.apiExtensionsV1beta1Lister +} + func (l *lister) OperatorsV1alpha1() OperatorsV1alpha1Lister { return l.operatorsV1alpha1Lister } @@ -184,7 +216,8 @@ func NewLister() OperatorLister { coreV1Lister: newCoreV1Lister(), rbacV1Lister: newRbacV1Lister(), apiRegistrationV1Lister: newAPIRegistrationV1Lister(), - + apiExtensionsV1beta1Lister: newAPIExtensionsV1beta1Lister(), + operatorsV1alpha1Lister: newOperatorsV1alpha1Lister(), operatorsV1alpha2Lister: newOperatorsV1alpha2Lister(), } diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_apiextensions_v1beta1lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_apiextensions_v1beta1lister.go new file mode 100644 index 0000000000..536cd24715 --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_apiextensions_v1beta1lister.go @@ -0,0 +1,140 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" + v1beta1 "k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1" +) + +type FakeAPIExtensionsV1beta1Lister struct { + CustomResourceDefinitionListerStub func() v1beta1.CustomResourceDefinitionLister + customResourceDefinitionListerMutex sync.RWMutex + customResourceDefinitionListerArgsForCall []struct { + } + customResourceDefinitionListerReturns struct { + result1 v1beta1.CustomResourceDefinitionLister + } + customResourceDefinitionListerReturnsOnCall map[int]struct { + result1 v1beta1.CustomResourceDefinitionLister + } + RegisterCustomResourceDefinitionListerStub func(v1beta1.CustomResourceDefinitionLister) + registerCustomResourceDefinitionListerMutex sync.RWMutex + registerCustomResourceDefinitionListerArgsForCall []struct { + arg1 v1beta1.CustomResourceDefinitionLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeAPIExtensionsV1beta1Lister) CustomResourceDefinitionLister() v1beta1.CustomResourceDefinitionLister { + fake.customResourceDefinitionListerMutex.Lock() + ret, specificReturn := fake.customResourceDefinitionListerReturnsOnCall[len(fake.customResourceDefinitionListerArgsForCall)] + fake.customResourceDefinitionListerArgsForCall = append(fake.customResourceDefinitionListerArgsForCall, struct { + }{}) + fake.recordInvocation("CustomResourceDefinitionLister", []interface{}{}) + fake.customResourceDefinitionListerMutex.Unlock() + if fake.CustomResourceDefinitionListerStub != nil { + return fake.CustomResourceDefinitionListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.customResourceDefinitionListerReturns + return fakeReturns.result1 +} + +func (fake *FakeAPIExtensionsV1beta1Lister) CustomResourceDefinitionListerCallCount() int { + fake.customResourceDefinitionListerMutex.RLock() + defer fake.customResourceDefinitionListerMutex.RUnlock() + return len(fake.customResourceDefinitionListerArgsForCall) +} + +func (fake *FakeAPIExtensionsV1beta1Lister) CustomResourceDefinitionListerCalls(stub func() v1beta1.CustomResourceDefinitionLister) { + fake.customResourceDefinitionListerMutex.Lock() + defer fake.customResourceDefinitionListerMutex.Unlock() + fake.CustomResourceDefinitionListerStub = stub +} + +func (fake *FakeAPIExtensionsV1beta1Lister) CustomResourceDefinitionListerReturns(result1 v1beta1.CustomResourceDefinitionLister) { + fake.customResourceDefinitionListerMutex.Lock() + defer fake.customResourceDefinitionListerMutex.Unlock() + fake.CustomResourceDefinitionListerStub = nil + fake.customResourceDefinitionListerReturns = struct { + result1 v1beta1.CustomResourceDefinitionLister + }{result1} +} + +func (fake *FakeAPIExtensionsV1beta1Lister) CustomResourceDefinitionListerReturnsOnCall(i int, result1 v1beta1.CustomResourceDefinitionLister) { + fake.customResourceDefinitionListerMutex.Lock() + defer fake.customResourceDefinitionListerMutex.Unlock() + fake.CustomResourceDefinitionListerStub = nil + if fake.customResourceDefinitionListerReturnsOnCall == nil { + fake.customResourceDefinitionListerReturnsOnCall = make(map[int]struct { + result1 v1beta1.CustomResourceDefinitionLister + }) + } + fake.customResourceDefinitionListerReturnsOnCall[i] = struct { + result1 v1beta1.CustomResourceDefinitionLister + }{result1} +} + +func (fake *FakeAPIExtensionsV1beta1Lister) RegisterCustomResourceDefinitionLister(arg1 v1beta1.CustomResourceDefinitionLister) { + fake.registerCustomResourceDefinitionListerMutex.Lock() + fake.registerCustomResourceDefinitionListerArgsForCall = append(fake.registerCustomResourceDefinitionListerArgsForCall, struct { + arg1 v1beta1.CustomResourceDefinitionLister + }{arg1}) + fake.recordInvocation("RegisterCustomResourceDefinitionLister", []interface{}{arg1}) + fake.registerCustomResourceDefinitionListerMutex.Unlock() + if fake.RegisterCustomResourceDefinitionListerStub != nil { + fake.RegisterCustomResourceDefinitionListerStub(arg1) + } +} + +func (fake *FakeAPIExtensionsV1beta1Lister) RegisterCustomResourceDefinitionListerCallCount() int { + fake.registerCustomResourceDefinitionListerMutex.RLock() + defer fake.registerCustomResourceDefinitionListerMutex.RUnlock() + return len(fake.registerCustomResourceDefinitionListerArgsForCall) +} + +func (fake *FakeAPIExtensionsV1beta1Lister) RegisterCustomResourceDefinitionListerCalls(stub func(v1beta1.CustomResourceDefinitionLister)) { + fake.registerCustomResourceDefinitionListerMutex.Lock() + defer fake.registerCustomResourceDefinitionListerMutex.Unlock() + fake.RegisterCustomResourceDefinitionListerStub = stub +} + +func (fake *FakeAPIExtensionsV1beta1Lister) RegisterCustomResourceDefinitionListerArgsForCall(i int) v1beta1.CustomResourceDefinitionLister { + fake.registerCustomResourceDefinitionListerMutex.RLock() + defer fake.registerCustomResourceDefinitionListerMutex.RUnlock() + argsForCall := fake.registerCustomResourceDefinitionListerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAPIExtensionsV1beta1Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.customResourceDefinitionListerMutex.RLock() + defer fake.customResourceDefinitionListerMutex.RUnlock() + fake.registerCustomResourceDefinitionListerMutex.RLock() + defer fake.registerCustomResourceDefinitionListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeAPIExtensionsV1beta1Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.APIExtensionsV1beta1Lister = new(FakeAPIExtensionsV1beta1Lister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_apiregistration_v1lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_apiregistration_v1lister.go new file mode 100644 index 0000000000..a27e12b40f --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_apiregistration_v1lister.go @@ -0,0 +1,140 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" + v1 "k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1" +) + +type FakeAPIRegistrationV1Lister struct { + APIServiceListerStub func() v1.APIServiceLister + aPIServiceListerMutex sync.RWMutex + aPIServiceListerArgsForCall []struct { + } + aPIServiceListerReturns struct { + result1 v1.APIServiceLister + } + aPIServiceListerReturnsOnCall map[int]struct { + result1 v1.APIServiceLister + } + RegisterAPIServiceListerStub func(v1.APIServiceLister) + registerAPIServiceListerMutex sync.RWMutex + registerAPIServiceListerArgsForCall []struct { + arg1 v1.APIServiceLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeAPIRegistrationV1Lister) APIServiceLister() v1.APIServiceLister { + fake.aPIServiceListerMutex.Lock() + ret, specificReturn := fake.aPIServiceListerReturnsOnCall[len(fake.aPIServiceListerArgsForCall)] + fake.aPIServiceListerArgsForCall = append(fake.aPIServiceListerArgsForCall, struct { + }{}) + fake.recordInvocation("APIServiceLister", []interface{}{}) + fake.aPIServiceListerMutex.Unlock() + if fake.APIServiceListerStub != nil { + return fake.APIServiceListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.aPIServiceListerReturns + return fakeReturns.result1 +} + +func (fake *FakeAPIRegistrationV1Lister) APIServiceListerCallCount() int { + fake.aPIServiceListerMutex.RLock() + defer fake.aPIServiceListerMutex.RUnlock() + return len(fake.aPIServiceListerArgsForCall) +} + +func (fake *FakeAPIRegistrationV1Lister) APIServiceListerCalls(stub func() v1.APIServiceLister) { + fake.aPIServiceListerMutex.Lock() + defer fake.aPIServiceListerMutex.Unlock() + fake.APIServiceListerStub = stub +} + +func (fake *FakeAPIRegistrationV1Lister) APIServiceListerReturns(result1 v1.APIServiceLister) { + fake.aPIServiceListerMutex.Lock() + defer fake.aPIServiceListerMutex.Unlock() + fake.APIServiceListerStub = nil + fake.aPIServiceListerReturns = struct { + result1 v1.APIServiceLister + }{result1} +} + +func (fake *FakeAPIRegistrationV1Lister) APIServiceListerReturnsOnCall(i int, result1 v1.APIServiceLister) { + fake.aPIServiceListerMutex.Lock() + defer fake.aPIServiceListerMutex.Unlock() + fake.APIServiceListerStub = nil + if fake.aPIServiceListerReturnsOnCall == nil { + fake.aPIServiceListerReturnsOnCall = make(map[int]struct { + result1 v1.APIServiceLister + }) + } + fake.aPIServiceListerReturnsOnCall[i] = struct { + result1 v1.APIServiceLister + }{result1} +} + +func (fake *FakeAPIRegistrationV1Lister) RegisterAPIServiceLister(arg1 v1.APIServiceLister) { + fake.registerAPIServiceListerMutex.Lock() + fake.registerAPIServiceListerArgsForCall = append(fake.registerAPIServiceListerArgsForCall, struct { + arg1 v1.APIServiceLister + }{arg1}) + fake.recordInvocation("RegisterAPIServiceLister", []interface{}{arg1}) + fake.registerAPIServiceListerMutex.Unlock() + if fake.RegisterAPIServiceListerStub != nil { + fake.RegisterAPIServiceListerStub(arg1) + } +} + +func (fake *FakeAPIRegistrationV1Lister) RegisterAPIServiceListerCallCount() int { + fake.registerAPIServiceListerMutex.RLock() + defer fake.registerAPIServiceListerMutex.RUnlock() + return len(fake.registerAPIServiceListerArgsForCall) +} + +func (fake *FakeAPIRegistrationV1Lister) RegisterAPIServiceListerCalls(stub func(v1.APIServiceLister)) { + fake.registerAPIServiceListerMutex.Lock() + defer fake.registerAPIServiceListerMutex.Unlock() + fake.RegisterAPIServiceListerStub = stub +} + +func (fake *FakeAPIRegistrationV1Lister) RegisterAPIServiceListerArgsForCall(i int) v1.APIServiceLister { + fake.registerAPIServiceListerMutex.RLock() + defer fake.registerAPIServiceListerMutex.RUnlock() + argsForCall := fake.registerAPIServiceListerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAPIRegistrationV1Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.aPIServiceListerMutex.RLock() + defer fake.aPIServiceListerMutex.RUnlock() + fake.registerAPIServiceListerMutex.RLock() + defer fake.registerAPIServiceListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeAPIRegistrationV1Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.APIRegistrationV1Lister = new(FakeAPIRegistrationV1Lister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_apps_v1lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_apps_v1lister.go new file mode 100644 index 0000000000..eb4224e2c7 --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_apps_v1lister.go @@ -0,0 +1,142 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" + v1 "k8s.io/client-go/listers/apps/v1" +) + +type FakeAppsV1Lister struct { + DeploymentListerStub func() v1.DeploymentLister + deploymentListerMutex sync.RWMutex + deploymentListerArgsForCall []struct { + } + deploymentListerReturns struct { + result1 v1.DeploymentLister + } + deploymentListerReturnsOnCall map[int]struct { + result1 v1.DeploymentLister + } + RegisterDeploymentListerStub func(string, v1.DeploymentLister) + registerDeploymentListerMutex sync.RWMutex + registerDeploymentListerArgsForCall []struct { + arg1 string + arg2 v1.DeploymentLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeAppsV1Lister) DeploymentLister() v1.DeploymentLister { + fake.deploymentListerMutex.Lock() + ret, specificReturn := fake.deploymentListerReturnsOnCall[len(fake.deploymentListerArgsForCall)] + fake.deploymentListerArgsForCall = append(fake.deploymentListerArgsForCall, struct { + }{}) + fake.recordInvocation("DeploymentLister", []interface{}{}) + fake.deploymentListerMutex.Unlock() + if fake.DeploymentListerStub != nil { + return fake.DeploymentListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.deploymentListerReturns + return fakeReturns.result1 +} + +func (fake *FakeAppsV1Lister) DeploymentListerCallCount() int { + fake.deploymentListerMutex.RLock() + defer fake.deploymentListerMutex.RUnlock() + return len(fake.deploymentListerArgsForCall) +} + +func (fake *FakeAppsV1Lister) DeploymentListerCalls(stub func() v1.DeploymentLister) { + fake.deploymentListerMutex.Lock() + defer fake.deploymentListerMutex.Unlock() + fake.DeploymentListerStub = stub +} + +func (fake *FakeAppsV1Lister) DeploymentListerReturns(result1 v1.DeploymentLister) { + fake.deploymentListerMutex.Lock() + defer fake.deploymentListerMutex.Unlock() + fake.DeploymentListerStub = nil + fake.deploymentListerReturns = struct { + result1 v1.DeploymentLister + }{result1} +} + +func (fake *FakeAppsV1Lister) DeploymentListerReturnsOnCall(i int, result1 v1.DeploymentLister) { + fake.deploymentListerMutex.Lock() + defer fake.deploymentListerMutex.Unlock() + fake.DeploymentListerStub = nil + if fake.deploymentListerReturnsOnCall == nil { + fake.deploymentListerReturnsOnCall = make(map[int]struct { + result1 v1.DeploymentLister + }) + } + fake.deploymentListerReturnsOnCall[i] = struct { + result1 v1.DeploymentLister + }{result1} +} + +func (fake *FakeAppsV1Lister) RegisterDeploymentLister(arg1 string, arg2 v1.DeploymentLister) { + fake.registerDeploymentListerMutex.Lock() + fake.registerDeploymentListerArgsForCall = append(fake.registerDeploymentListerArgsForCall, struct { + arg1 string + arg2 v1.DeploymentLister + }{arg1, arg2}) + fake.recordInvocation("RegisterDeploymentLister", []interface{}{arg1, arg2}) + fake.registerDeploymentListerMutex.Unlock() + if fake.RegisterDeploymentListerStub != nil { + fake.RegisterDeploymentListerStub(arg1, arg2) + } +} + +func (fake *FakeAppsV1Lister) RegisterDeploymentListerCallCount() int { + fake.registerDeploymentListerMutex.RLock() + defer fake.registerDeploymentListerMutex.RUnlock() + return len(fake.registerDeploymentListerArgsForCall) +} + +func (fake *FakeAppsV1Lister) RegisterDeploymentListerCalls(stub func(string, v1.DeploymentLister)) { + fake.registerDeploymentListerMutex.Lock() + defer fake.registerDeploymentListerMutex.Unlock() + fake.RegisterDeploymentListerStub = stub +} + +func (fake *FakeAppsV1Lister) RegisterDeploymentListerArgsForCall(i int) (string, v1.DeploymentLister) { + fake.registerDeploymentListerMutex.RLock() + defer fake.registerDeploymentListerMutex.RUnlock() + argsForCall := fake.registerDeploymentListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeAppsV1Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.deploymentListerMutex.RLock() + defer fake.deploymentListerMutex.RUnlock() + fake.registerDeploymentListerMutex.RLock() + defer fake.registerDeploymentListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeAppsV1Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.AppsV1Lister = new(FakeAppsV1Lister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_core_v1lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_core_v1lister.go new file mode 100644 index 0000000000..9bc8491608 --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_core_v1lister.go @@ -0,0 +1,452 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" + v1 "k8s.io/client-go/listers/core/v1" +) + +type FakeCoreV1Lister struct { + NamespaceListerStub func() v1.NamespaceLister + namespaceListerMutex sync.RWMutex + namespaceListerArgsForCall []struct { + } + namespaceListerReturns struct { + result1 v1.NamespaceLister + } + namespaceListerReturnsOnCall map[int]struct { + result1 v1.NamespaceLister + } + RegisterNamespaceListerStub func(v1.NamespaceLister) + registerNamespaceListerMutex sync.RWMutex + registerNamespaceListerArgsForCall []struct { + arg1 v1.NamespaceLister + } + RegisterSecretListerStub func(string, v1.SecretLister) + registerSecretListerMutex sync.RWMutex + registerSecretListerArgsForCall []struct { + arg1 string + arg2 v1.SecretLister + } + RegisterServiceAccountListerStub func(string, v1.ServiceAccountLister) + registerServiceAccountListerMutex sync.RWMutex + registerServiceAccountListerArgsForCall []struct { + arg1 string + arg2 v1.ServiceAccountLister + } + RegisterServiceListerStub func(string, v1.ServiceLister) + registerServiceListerMutex sync.RWMutex + registerServiceListerArgsForCall []struct { + arg1 string + arg2 v1.ServiceLister + } + SecretListerStub func() v1.SecretLister + secretListerMutex sync.RWMutex + secretListerArgsForCall []struct { + } + secretListerReturns struct { + result1 v1.SecretLister + } + secretListerReturnsOnCall map[int]struct { + result1 v1.SecretLister + } + ServiceAccountListerStub func() v1.ServiceAccountLister + serviceAccountListerMutex sync.RWMutex + serviceAccountListerArgsForCall []struct { + } + serviceAccountListerReturns struct { + result1 v1.ServiceAccountLister + } + serviceAccountListerReturnsOnCall map[int]struct { + result1 v1.ServiceAccountLister + } + ServiceListerStub func() v1.ServiceLister + serviceListerMutex sync.RWMutex + serviceListerArgsForCall []struct { + } + serviceListerReturns struct { + result1 v1.ServiceLister + } + serviceListerReturnsOnCall map[int]struct { + result1 v1.ServiceLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeCoreV1Lister) NamespaceLister() v1.NamespaceLister { + fake.namespaceListerMutex.Lock() + ret, specificReturn := fake.namespaceListerReturnsOnCall[len(fake.namespaceListerArgsForCall)] + fake.namespaceListerArgsForCall = append(fake.namespaceListerArgsForCall, struct { + }{}) + fake.recordInvocation("NamespaceLister", []interface{}{}) + fake.namespaceListerMutex.Unlock() + if fake.NamespaceListerStub != nil { + return fake.NamespaceListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.namespaceListerReturns + return fakeReturns.result1 +} + +func (fake *FakeCoreV1Lister) NamespaceListerCallCount() int { + fake.namespaceListerMutex.RLock() + defer fake.namespaceListerMutex.RUnlock() + return len(fake.namespaceListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) NamespaceListerCalls(stub func() v1.NamespaceLister) { + fake.namespaceListerMutex.Lock() + defer fake.namespaceListerMutex.Unlock() + fake.NamespaceListerStub = stub +} + +func (fake *FakeCoreV1Lister) NamespaceListerReturns(result1 v1.NamespaceLister) { + fake.namespaceListerMutex.Lock() + defer fake.namespaceListerMutex.Unlock() + fake.NamespaceListerStub = nil + fake.namespaceListerReturns = struct { + result1 v1.NamespaceLister + }{result1} +} + +func (fake *FakeCoreV1Lister) NamespaceListerReturnsOnCall(i int, result1 v1.NamespaceLister) { + fake.namespaceListerMutex.Lock() + defer fake.namespaceListerMutex.Unlock() + fake.NamespaceListerStub = nil + if fake.namespaceListerReturnsOnCall == nil { + fake.namespaceListerReturnsOnCall = make(map[int]struct { + result1 v1.NamespaceLister + }) + } + fake.namespaceListerReturnsOnCall[i] = struct { + result1 v1.NamespaceLister + }{result1} +} + +func (fake *FakeCoreV1Lister) RegisterNamespaceLister(arg1 v1.NamespaceLister) { + fake.registerNamespaceListerMutex.Lock() + fake.registerNamespaceListerArgsForCall = append(fake.registerNamespaceListerArgsForCall, struct { + arg1 v1.NamespaceLister + }{arg1}) + fake.recordInvocation("RegisterNamespaceLister", []interface{}{arg1}) + fake.registerNamespaceListerMutex.Unlock() + if fake.RegisterNamespaceListerStub != nil { + fake.RegisterNamespaceListerStub(arg1) + } +} + +func (fake *FakeCoreV1Lister) RegisterNamespaceListerCallCount() int { + fake.registerNamespaceListerMutex.RLock() + defer fake.registerNamespaceListerMutex.RUnlock() + return len(fake.registerNamespaceListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) RegisterNamespaceListerCalls(stub func(v1.NamespaceLister)) { + fake.registerNamespaceListerMutex.Lock() + defer fake.registerNamespaceListerMutex.Unlock() + fake.RegisterNamespaceListerStub = stub +} + +func (fake *FakeCoreV1Lister) RegisterNamespaceListerArgsForCall(i int) v1.NamespaceLister { + fake.registerNamespaceListerMutex.RLock() + defer fake.registerNamespaceListerMutex.RUnlock() + argsForCall := fake.registerNamespaceListerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCoreV1Lister) RegisterSecretLister(arg1 string, arg2 v1.SecretLister) { + fake.registerSecretListerMutex.Lock() + fake.registerSecretListerArgsForCall = append(fake.registerSecretListerArgsForCall, struct { + arg1 string + arg2 v1.SecretLister + }{arg1, arg2}) + fake.recordInvocation("RegisterSecretLister", []interface{}{arg1, arg2}) + fake.registerSecretListerMutex.Unlock() + if fake.RegisterSecretListerStub != nil { + fake.RegisterSecretListerStub(arg1, arg2) + } +} + +func (fake *FakeCoreV1Lister) RegisterSecretListerCallCount() int { + fake.registerSecretListerMutex.RLock() + defer fake.registerSecretListerMutex.RUnlock() + return len(fake.registerSecretListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) RegisterSecretListerCalls(stub func(string, v1.SecretLister)) { + fake.registerSecretListerMutex.Lock() + defer fake.registerSecretListerMutex.Unlock() + fake.RegisterSecretListerStub = stub +} + +func (fake *FakeCoreV1Lister) RegisterSecretListerArgsForCall(i int) (string, v1.SecretLister) { + fake.registerSecretListerMutex.RLock() + defer fake.registerSecretListerMutex.RUnlock() + argsForCall := fake.registerSecretListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCoreV1Lister) RegisterServiceAccountLister(arg1 string, arg2 v1.ServiceAccountLister) { + fake.registerServiceAccountListerMutex.Lock() + fake.registerServiceAccountListerArgsForCall = append(fake.registerServiceAccountListerArgsForCall, struct { + arg1 string + arg2 v1.ServiceAccountLister + }{arg1, arg2}) + fake.recordInvocation("RegisterServiceAccountLister", []interface{}{arg1, arg2}) + fake.registerServiceAccountListerMutex.Unlock() + if fake.RegisterServiceAccountListerStub != nil { + fake.RegisterServiceAccountListerStub(arg1, arg2) + } +} + +func (fake *FakeCoreV1Lister) RegisterServiceAccountListerCallCount() int { + fake.registerServiceAccountListerMutex.RLock() + defer fake.registerServiceAccountListerMutex.RUnlock() + return len(fake.registerServiceAccountListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) RegisterServiceAccountListerCalls(stub func(string, v1.ServiceAccountLister)) { + fake.registerServiceAccountListerMutex.Lock() + defer fake.registerServiceAccountListerMutex.Unlock() + fake.RegisterServiceAccountListerStub = stub +} + +func (fake *FakeCoreV1Lister) RegisterServiceAccountListerArgsForCall(i int) (string, v1.ServiceAccountLister) { + fake.registerServiceAccountListerMutex.RLock() + defer fake.registerServiceAccountListerMutex.RUnlock() + argsForCall := fake.registerServiceAccountListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCoreV1Lister) RegisterServiceLister(arg1 string, arg2 v1.ServiceLister) { + fake.registerServiceListerMutex.Lock() + fake.registerServiceListerArgsForCall = append(fake.registerServiceListerArgsForCall, struct { + arg1 string + arg2 v1.ServiceLister + }{arg1, arg2}) + fake.recordInvocation("RegisterServiceLister", []interface{}{arg1, arg2}) + fake.registerServiceListerMutex.Unlock() + if fake.RegisterServiceListerStub != nil { + fake.RegisterServiceListerStub(arg1, arg2) + } +} + +func (fake *FakeCoreV1Lister) RegisterServiceListerCallCount() int { + fake.registerServiceListerMutex.RLock() + defer fake.registerServiceListerMutex.RUnlock() + return len(fake.registerServiceListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) RegisterServiceListerCalls(stub func(string, v1.ServiceLister)) { + fake.registerServiceListerMutex.Lock() + defer fake.registerServiceListerMutex.Unlock() + fake.RegisterServiceListerStub = stub +} + +func (fake *FakeCoreV1Lister) RegisterServiceListerArgsForCall(i int) (string, v1.ServiceLister) { + fake.registerServiceListerMutex.RLock() + defer fake.registerServiceListerMutex.RUnlock() + argsForCall := fake.registerServiceListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCoreV1Lister) SecretLister() v1.SecretLister { + fake.secretListerMutex.Lock() + ret, specificReturn := fake.secretListerReturnsOnCall[len(fake.secretListerArgsForCall)] + fake.secretListerArgsForCall = append(fake.secretListerArgsForCall, struct { + }{}) + fake.recordInvocation("SecretLister", []interface{}{}) + fake.secretListerMutex.Unlock() + if fake.SecretListerStub != nil { + return fake.SecretListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.secretListerReturns + return fakeReturns.result1 +} + +func (fake *FakeCoreV1Lister) SecretListerCallCount() int { + fake.secretListerMutex.RLock() + defer fake.secretListerMutex.RUnlock() + return len(fake.secretListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) SecretListerCalls(stub func() v1.SecretLister) { + fake.secretListerMutex.Lock() + defer fake.secretListerMutex.Unlock() + fake.SecretListerStub = stub +} + +func (fake *FakeCoreV1Lister) SecretListerReturns(result1 v1.SecretLister) { + fake.secretListerMutex.Lock() + defer fake.secretListerMutex.Unlock() + fake.SecretListerStub = nil + fake.secretListerReturns = struct { + result1 v1.SecretLister + }{result1} +} + +func (fake *FakeCoreV1Lister) SecretListerReturnsOnCall(i int, result1 v1.SecretLister) { + fake.secretListerMutex.Lock() + defer fake.secretListerMutex.Unlock() + fake.SecretListerStub = nil + if fake.secretListerReturnsOnCall == nil { + fake.secretListerReturnsOnCall = make(map[int]struct { + result1 v1.SecretLister + }) + } + fake.secretListerReturnsOnCall[i] = struct { + result1 v1.SecretLister + }{result1} +} + +func (fake *FakeCoreV1Lister) ServiceAccountLister() v1.ServiceAccountLister { + fake.serviceAccountListerMutex.Lock() + ret, specificReturn := fake.serviceAccountListerReturnsOnCall[len(fake.serviceAccountListerArgsForCall)] + fake.serviceAccountListerArgsForCall = append(fake.serviceAccountListerArgsForCall, struct { + }{}) + fake.recordInvocation("ServiceAccountLister", []interface{}{}) + fake.serviceAccountListerMutex.Unlock() + if fake.ServiceAccountListerStub != nil { + return fake.ServiceAccountListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.serviceAccountListerReturns + return fakeReturns.result1 +} + +func (fake *FakeCoreV1Lister) ServiceAccountListerCallCount() int { + fake.serviceAccountListerMutex.RLock() + defer fake.serviceAccountListerMutex.RUnlock() + return len(fake.serviceAccountListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) ServiceAccountListerCalls(stub func() v1.ServiceAccountLister) { + fake.serviceAccountListerMutex.Lock() + defer fake.serviceAccountListerMutex.Unlock() + fake.ServiceAccountListerStub = stub +} + +func (fake *FakeCoreV1Lister) ServiceAccountListerReturns(result1 v1.ServiceAccountLister) { + fake.serviceAccountListerMutex.Lock() + defer fake.serviceAccountListerMutex.Unlock() + fake.ServiceAccountListerStub = nil + fake.serviceAccountListerReturns = struct { + result1 v1.ServiceAccountLister + }{result1} +} + +func (fake *FakeCoreV1Lister) ServiceAccountListerReturnsOnCall(i int, result1 v1.ServiceAccountLister) { + fake.serviceAccountListerMutex.Lock() + defer fake.serviceAccountListerMutex.Unlock() + fake.ServiceAccountListerStub = nil + if fake.serviceAccountListerReturnsOnCall == nil { + fake.serviceAccountListerReturnsOnCall = make(map[int]struct { + result1 v1.ServiceAccountLister + }) + } + fake.serviceAccountListerReturnsOnCall[i] = struct { + result1 v1.ServiceAccountLister + }{result1} +} + +func (fake *FakeCoreV1Lister) ServiceLister() v1.ServiceLister { + fake.serviceListerMutex.Lock() + ret, specificReturn := fake.serviceListerReturnsOnCall[len(fake.serviceListerArgsForCall)] + fake.serviceListerArgsForCall = append(fake.serviceListerArgsForCall, struct { + }{}) + fake.recordInvocation("ServiceLister", []interface{}{}) + fake.serviceListerMutex.Unlock() + if fake.ServiceListerStub != nil { + return fake.ServiceListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.serviceListerReturns + return fakeReturns.result1 +} + +func (fake *FakeCoreV1Lister) ServiceListerCallCount() int { + fake.serviceListerMutex.RLock() + defer fake.serviceListerMutex.RUnlock() + return len(fake.serviceListerArgsForCall) +} + +func (fake *FakeCoreV1Lister) ServiceListerCalls(stub func() v1.ServiceLister) { + fake.serviceListerMutex.Lock() + defer fake.serviceListerMutex.Unlock() + fake.ServiceListerStub = stub +} + +func (fake *FakeCoreV1Lister) ServiceListerReturns(result1 v1.ServiceLister) { + fake.serviceListerMutex.Lock() + defer fake.serviceListerMutex.Unlock() + fake.ServiceListerStub = nil + fake.serviceListerReturns = struct { + result1 v1.ServiceLister + }{result1} +} + +func (fake *FakeCoreV1Lister) ServiceListerReturnsOnCall(i int, result1 v1.ServiceLister) { + fake.serviceListerMutex.Lock() + defer fake.serviceListerMutex.Unlock() + fake.ServiceListerStub = nil + if fake.serviceListerReturnsOnCall == nil { + fake.serviceListerReturnsOnCall = make(map[int]struct { + result1 v1.ServiceLister + }) + } + fake.serviceListerReturnsOnCall[i] = struct { + result1 v1.ServiceLister + }{result1} +} + +func (fake *FakeCoreV1Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.namespaceListerMutex.RLock() + defer fake.namespaceListerMutex.RUnlock() + fake.registerNamespaceListerMutex.RLock() + defer fake.registerNamespaceListerMutex.RUnlock() + fake.registerSecretListerMutex.RLock() + defer fake.registerSecretListerMutex.RUnlock() + fake.registerServiceAccountListerMutex.RLock() + defer fake.registerServiceAccountListerMutex.RUnlock() + fake.registerServiceListerMutex.RLock() + defer fake.registerServiceListerMutex.RUnlock() + fake.secretListerMutex.RLock() + defer fake.secretListerMutex.RUnlock() + fake.serviceAccountListerMutex.RLock() + defer fake.serviceAccountListerMutex.RUnlock() + fake.serviceListerMutex.RLock() + defer fake.serviceListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeCoreV1Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.CoreV1Lister = new(FakeCoreV1Lister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_operator_lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_operator_lister.go new file mode 100644 index 0000000000..395ae5b54d --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_operator_lister.go @@ -0,0 +1,485 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" +) + +type FakeOperatorLister struct { + APIExtensionsV1beta1Stub func() operatorlister.APIExtensionsV1beta1Lister + aPIExtensionsV1beta1Mutex sync.RWMutex + aPIExtensionsV1beta1ArgsForCall []struct { + } + aPIExtensionsV1beta1Returns struct { + result1 operatorlister.APIExtensionsV1beta1Lister + } + aPIExtensionsV1beta1ReturnsOnCall map[int]struct { + result1 operatorlister.APIExtensionsV1beta1Lister + } + APIRegistrationV1Stub func() operatorlister.APIRegistrationV1Lister + aPIRegistrationV1Mutex sync.RWMutex + aPIRegistrationV1ArgsForCall []struct { + } + aPIRegistrationV1Returns struct { + result1 operatorlister.APIRegistrationV1Lister + } + aPIRegistrationV1ReturnsOnCall map[int]struct { + result1 operatorlister.APIRegistrationV1Lister + } + AppsV1Stub func() operatorlister.AppsV1Lister + appsV1Mutex sync.RWMutex + appsV1ArgsForCall []struct { + } + appsV1Returns struct { + result1 operatorlister.AppsV1Lister + } + appsV1ReturnsOnCall map[int]struct { + result1 operatorlister.AppsV1Lister + } + CoreV1Stub func() operatorlister.CoreV1Lister + coreV1Mutex sync.RWMutex + coreV1ArgsForCall []struct { + } + coreV1Returns struct { + result1 operatorlister.CoreV1Lister + } + coreV1ReturnsOnCall map[int]struct { + result1 operatorlister.CoreV1Lister + } + OperatorsV1alpha1Stub func() operatorlister.OperatorsV1alpha1Lister + operatorsV1alpha1Mutex sync.RWMutex + operatorsV1alpha1ArgsForCall []struct { + } + operatorsV1alpha1Returns struct { + result1 operatorlister.OperatorsV1alpha1Lister + } + operatorsV1alpha1ReturnsOnCall map[int]struct { + result1 operatorlister.OperatorsV1alpha1Lister + } + OperatorsV1alpha2Stub func() operatorlister.OperatorsV1alpha2Lister + operatorsV1alpha2Mutex sync.RWMutex + operatorsV1alpha2ArgsForCall []struct { + } + operatorsV1alpha2Returns struct { + result1 operatorlister.OperatorsV1alpha2Lister + } + operatorsV1alpha2ReturnsOnCall map[int]struct { + result1 operatorlister.OperatorsV1alpha2Lister + } + RbacV1Stub func() operatorlister.RbacV1Lister + rbacV1Mutex sync.RWMutex + rbacV1ArgsForCall []struct { + } + rbacV1Returns struct { + result1 operatorlister.RbacV1Lister + } + rbacV1ReturnsOnCall map[int]struct { + result1 operatorlister.RbacV1Lister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeOperatorLister) APIExtensionsV1beta1() operatorlister.APIExtensionsV1beta1Lister { + fake.aPIExtensionsV1beta1Mutex.Lock() + ret, specificReturn := fake.aPIExtensionsV1beta1ReturnsOnCall[len(fake.aPIExtensionsV1beta1ArgsForCall)] + fake.aPIExtensionsV1beta1ArgsForCall = append(fake.aPIExtensionsV1beta1ArgsForCall, struct { + }{}) + fake.recordInvocation("APIExtensionsV1beta1", []interface{}{}) + fake.aPIExtensionsV1beta1Mutex.Unlock() + if fake.APIExtensionsV1beta1Stub != nil { + return fake.APIExtensionsV1beta1Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.aPIExtensionsV1beta1Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) APIExtensionsV1beta1CallCount() int { + fake.aPIExtensionsV1beta1Mutex.RLock() + defer fake.aPIExtensionsV1beta1Mutex.RUnlock() + return len(fake.aPIExtensionsV1beta1ArgsForCall) +} + +func (fake *FakeOperatorLister) APIExtensionsV1beta1Calls(stub func() operatorlister.APIExtensionsV1beta1Lister) { + fake.aPIExtensionsV1beta1Mutex.Lock() + defer fake.aPIExtensionsV1beta1Mutex.Unlock() + fake.APIExtensionsV1beta1Stub = stub +} + +func (fake *FakeOperatorLister) APIExtensionsV1beta1Returns(result1 operatorlister.APIExtensionsV1beta1Lister) { + fake.aPIExtensionsV1beta1Mutex.Lock() + defer fake.aPIExtensionsV1beta1Mutex.Unlock() + fake.APIExtensionsV1beta1Stub = nil + fake.aPIExtensionsV1beta1Returns = struct { + result1 operatorlister.APIExtensionsV1beta1Lister + }{result1} +} + +func (fake *FakeOperatorLister) APIExtensionsV1beta1ReturnsOnCall(i int, result1 operatorlister.APIExtensionsV1beta1Lister) { + fake.aPIExtensionsV1beta1Mutex.Lock() + defer fake.aPIExtensionsV1beta1Mutex.Unlock() + fake.APIExtensionsV1beta1Stub = nil + if fake.aPIExtensionsV1beta1ReturnsOnCall == nil { + fake.aPIExtensionsV1beta1ReturnsOnCall = make(map[int]struct { + result1 operatorlister.APIExtensionsV1beta1Lister + }) + } + fake.aPIExtensionsV1beta1ReturnsOnCall[i] = struct { + result1 operatorlister.APIExtensionsV1beta1Lister + }{result1} +} + +func (fake *FakeOperatorLister) APIRegistrationV1() operatorlister.APIRegistrationV1Lister { + fake.aPIRegistrationV1Mutex.Lock() + ret, specificReturn := fake.aPIRegistrationV1ReturnsOnCall[len(fake.aPIRegistrationV1ArgsForCall)] + fake.aPIRegistrationV1ArgsForCall = append(fake.aPIRegistrationV1ArgsForCall, struct { + }{}) + fake.recordInvocation("APIRegistrationV1", []interface{}{}) + fake.aPIRegistrationV1Mutex.Unlock() + if fake.APIRegistrationV1Stub != nil { + return fake.APIRegistrationV1Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.aPIRegistrationV1Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) APIRegistrationV1CallCount() int { + fake.aPIRegistrationV1Mutex.RLock() + defer fake.aPIRegistrationV1Mutex.RUnlock() + return len(fake.aPIRegistrationV1ArgsForCall) +} + +func (fake *FakeOperatorLister) APIRegistrationV1Calls(stub func() operatorlister.APIRegistrationV1Lister) { + fake.aPIRegistrationV1Mutex.Lock() + defer fake.aPIRegistrationV1Mutex.Unlock() + fake.APIRegistrationV1Stub = stub +} + +func (fake *FakeOperatorLister) APIRegistrationV1Returns(result1 operatorlister.APIRegistrationV1Lister) { + fake.aPIRegistrationV1Mutex.Lock() + defer fake.aPIRegistrationV1Mutex.Unlock() + fake.APIRegistrationV1Stub = nil + fake.aPIRegistrationV1Returns = struct { + result1 operatorlister.APIRegistrationV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) APIRegistrationV1ReturnsOnCall(i int, result1 operatorlister.APIRegistrationV1Lister) { + fake.aPIRegistrationV1Mutex.Lock() + defer fake.aPIRegistrationV1Mutex.Unlock() + fake.APIRegistrationV1Stub = nil + if fake.aPIRegistrationV1ReturnsOnCall == nil { + fake.aPIRegistrationV1ReturnsOnCall = make(map[int]struct { + result1 operatorlister.APIRegistrationV1Lister + }) + } + fake.aPIRegistrationV1ReturnsOnCall[i] = struct { + result1 operatorlister.APIRegistrationV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) AppsV1() operatorlister.AppsV1Lister { + fake.appsV1Mutex.Lock() + ret, specificReturn := fake.appsV1ReturnsOnCall[len(fake.appsV1ArgsForCall)] + fake.appsV1ArgsForCall = append(fake.appsV1ArgsForCall, struct { + }{}) + fake.recordInvocation("AppsV1", []interface{}{}) + fake.appsV1Mutex.Unlock() + if fake.AppsV1Stub != nil { + return fake.AppsV1Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.appsV1Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) AppsV1CallCount() int { + fake.appsV1Mutex.RLock() + defer fake.appsV1Mutex.RUnlock() + return len(fake.appsV1ArgsForCall) +} + +func (fake *FakeOperatorLister) AppsV1Calls(stub func() operatorlister.AppsV1Lister) { + fake.appsV1Mutex.Lock() + defer fake.appsV1Mutex.Unlock() + fake.AppsV1Stub = stub +} + +func (fake *FakeOperatorLister) AppsV1Returns(result1 operatorlister.AppsV1Lister) { + fake.appsV1Mutex.Lock() + defer fake.appsV1Mutex.Unlock() + fake.AppsV1Stub = nil + fake.appsV1Returns = struct { + result1 operatorlister.AppsV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) AppsV1ReturnsOnCall(i int, result1 operatorlister.AppsV1Lister) { + fake.appsV1Mutex.Lock() + defer fake.appsV1Mutex.Unlock() + fake.AppsV1Stub = nil + if fake.appsV1ReturnsOnCall == nil { + fake.appsV1ReturnsOnCall = make(map[int]struct { + result1 operatorlister.AppsV1Lister + }) + } + fake.appsV1ReturnsOnCall[i] = struct { + result1 operatorlister.AppsV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) CoreV1() operatorlister.CoreV1Lister { + fake.coreV1Mutex.Lock() + ret, specificReturn := fake.coreV1ReturnsOnCall[len(fake.coreV1ArgsForCall)] + fake.coreV1ArgsForCall = append(fake.coreV1ArgsForCall, struct { + }{}) + fake.recordInvocation("CoreV1", []interface{}{}) + fake.coreV1Mutex.Unlock() + if fake.CoreV1Stub != nil { + return fake.CoreV1Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.coreV1Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) CoreV1CallCount() int { + fake.coreV1Mutex.RLock() + defer fake.coreV1Mutex.RUnlock() + return len(fake.coreV1ArgsForCall) +} + +func (fake *FakeOperatorLister) CoreV1Calls(stub func() operatorlister.CoreV1Lister) { + fake.coreV1Mutex.Lock() + defer fake.coreV1Mutex.Unlock() + fake.CoreV1Stub = stub +} + +func (fake *FakeOperatorLister) CoreV1Returns(result1 operatorlister.CoreV1Lister) { + fake.coreV1Mutex.Lock() + defer fake.coreV1Mutex.Unlock() + fake.CoreV1Stub = nil + fake.coreV1Returns = struct { + result1 operatorlister.CoreV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) CoreV1ReturnsOnCall(i int, result1 operatorlister.CoreV1Lister) { + fake.coreV1Mutex.Lock() + defer fake.coreV1Mutex.Unlock() + fake.CoreV1Stub = nil + if fake.coreV1ReturnsOnCall == nil { + fake.coreV1ReturnsOnCall = make(map[int]struct { + result1 operatorlister.CoreV1Lister + }) + } + fake.coreV1ReturnsOnCall[i] = struct { + result1 operatorlister.CoreV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) OperatorsV1alpha1() operatorlister.OperatorsV1alpha1Lister { + fake.operatorsV1alpha1Mutex.Lock() + ret, specificReturn := fake.operatorsV1alpha1ReturnsOnCall[len(fake.operatorsV1alpha1ArgsForCall)] + fake.operatorsV1alpha1ArgsForCall = append(fake.operatorsV1alpha1ArgsForCall, struct { + }{}) + fake.recordInvocation("OperatorsV1alpha1", []interface{}{}) + fake.operatorsV1alpha1Mutex.Unlock() + if fake.OperatorsV1alpha1Stub != nil { + return fake.OperatorsV1alpha1Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.operatorsV1alpha1Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) OperatorsV1alpha1CallCount() int { + fake.operatorsV1alpha1Mutex.RLock() + defer fake.operatorsV1alpha1Mutex.RUnlock() + return len(fake.operatorsV1alpha1ArgsForCall) +} + +func (fake *FakeOperatorLister) OperatorsV1alpha1Calls(stub func() operatorlister.OperatorsV1alpha1Lister) { + fake.operatorsV1alpha1Mutex.Lock() + defer fake.operatorsV1alpha1Mutex.Unlock() + fake.OperatorsV1alpha1Stub = stub +} + +func (fake *FakeOperatorLister) OperatorsV1alpha1Returns(result1 operatorlister.OperatorsV1alpha1Lister) { + fake.operatorsV1alpha1Mutex.Lock() + defer fake.operatorsV1alpha1Mutex.Unlock() + fake.OperatorsV1alpha1Stub = nil + fake.operatorsV1alpha1Returns = struct { + result1 operatorlister.OperatorsV1alpha1Lister + }{result1} +} + +func (fake *FakeOperatorLister) OperatorsV1alpha1ReturnsOnCall(i int, result1 operatorlister.OperatorsV1alpha1Lister) { + fake.operatorsV1alpha1Mutex.Lock() + defer fake.operatorsV1alpha1Mutex.Unlock() + fake.OperatorsV1alpha1Stub = nil + if fake.operatorsV1alpha1ReturnsOnCall == nil { + fake.operatorsV1alpha1ReturnsOnCall = make(map[int]struct { + result1 operatorlister.OperatorsV1alpha1Lister + }) + } + fake.operatorsV1alpha1ReturnsOnCall[i] = struct { + result1 operatorlister.OperatorsV1alpha1Lister + }{result1} +} + +func (fake *FakeOperatorLister) OperatorsV1alpha2() operatorlister.OperatorsV1alpha2Lister { + fake.operatorsV1alpha2Mutex.Lock() + ret, specificReturn := fake.operatorsV1alpha2ReturnsOnCall[len(fake.operatorsV1alpha2ArgsForCall)] + fake.operatorsV1alpha2ArgsForCall = append(fake.operatorsV1alpha2ArgsForCall, struct { + }{}) + fake.recordInvocation("OperatorsV1alpha2", []interface{}{}) + fake.operatorsV1alpha2Mutex.Unlock() + if fake.OperatorsV1alpha2Stub != nil { + return fake.OperatorsV1alpha2Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.operatorsV1alpha2Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) OperatorsV1alpha2CallCount() int { + fake.operatorsV1alpha2Mutex.RLock() + defer fake.operatorsV1alpha2Mutex.RUnlock() + return len(fake.operatorsV1alpha2ArgsForCall) +} + +func (fake *FakeOperatorLister) OperatorsV1alpha2Calls(stub func() operatorlister.OperatorsV1alpha2Lister) { + fake.operatorsV1alpha2Mutex.Lock() + defer fake.operatorsV1alpha2Mutex.Unlock() + fake.OperatorsV1alpha2Stub = stub +} + +func (fake *FakeOperatorLister) OperatorsV1alpha2Returns(result1 operatorlister.OperatorsV1alpha2Lister) { + fake.operatorsV1alpha2Mutex.Lock() + defer fake.operatorsV1alpha2Mutex.Unlock() + fake.OperatorsV1alpha2Stub = nil + fake.operatorsV1alpha2Returns = struct { + result1 operatorlister.OperatorsV1alpha2Lister + }{result1} +} + +func (fake *FakeOperatorLister) OperatorsV1alpha2ReturnsOnCall(i int, result1 operatorlister.OperatorsV1alpha2Lister) { + fake.operatorsV1alpha2Mutex.Lock() + defer fake.operatorsV1alpha2Mutex.Unlock() + fake.OperatorsV1alpha2Stub = nil + if fake.operatorsV1alpha2ReturnsOnCall == nil { + fake.operatorsV1alpha2ReturnsOnCall = make(map[int]struct { + result1 operatorlister.OperatorsV1alpha2Lister + }) + } + fake.operatorsV1alpha2ReturnsOnCall[i] = struct { + result1 operatorlister.OperatorsV1alpha2Lister + }{result1} +} + +func (fake *FakeOperatorLister) RbacV1() operatorlister.RbacV1Lister { + fake.rbacV1Mutex.Lock() + ret, specificReturn := fake.rbacV1ReturnsOnCall[len(fake.rbacV1ArgsForCall)] + fake.rbacV1ArgsForCall = append(fake.rbacV1ArgsForCall, struct { + }{}) + fake.recordInvocation("RbacV1", []interface{}{}) + fake.rbacV1Mutex.Unlock() + if fake.RbacV1Stub != nil { + return fake.RbacV1Stub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.rbacV1Returns + return fakeReturns.result1 +} + +func (fake *FakeOperatorLister) RbacV1CallCount() int { + fake.rbacV1Mutex.RLock() + defer fake.rbacV1Mutex.RUnlock() + return len(fake.rbacV1ArgsForCall) +} + +func (fake *FakeOperatorLister) RbacV1Calls(stub func() operatorlister.RbacV1Lister) { + fake.rbacV1Mutex.Lock() + defer fake.rbacV1Mutex.Unlock() + fake.RbacV1Stub = stub +} + +func (fake *FakeOperatorLister) RbacV1Returns(result1 operatorlister.RbacV1Lister) { + fake.rbacV1Mutex.Lock() + defer fake.rbacV1Mutex.Unlock() + fake.RbacV1Stub = nil + fake.rbacV1Returns = struct { + result1 operatorlister.RbacV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) RbacV1ReturnsOnCall(i int, result1 operatorlister.RbacV1Lister) { + fake.rbacV1Mutex.Lock() + defer fake.rbacV1Mutex.Unlock() + fake.RbacV1Stub = nil + if fake.rbacV1ReturnsOnCall == nil { + fake.rbacV1ReturnsOnCall = make(map[int]struct { + result1 operatorlister.RbacV1Lister + }) + } + fake.rbacV1ReturnsOnCall[i] = struct { + result1 operatorlister.RbacV1Lister + }{result1} +} + +func (fake *FakeOperatorLister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.aPIExtensionsV1beta1Mutex.RLock() + defer fake.aPIExtensionsV1beta1Mutex.RUnlock() + fake.aPIRegistrationV1Mutex.RLock() + defer fake.aPIRegistrationV1Mutex.RUnlock() + fake.appsV1Mutex.RLock() + defer fake.appsV1Mutex.RUnlock() + fake.coreV1Mutex.RLock() + defer fake.coreV1Mutex.RUnlock() + fake.operatorsV1alpha1Mutex.RLock() + defer fake.operatorsV1alpha1Mutex.RUnlock() + fake.operatorsV1alpha2Mutex.RLock() + defer fake.operatorsV1alpha2Mutex.RUnlock() + fake.rbacV1Mutex.RLock() + defer fake.rbacV1Mutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeOperatorLister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.OperatorLister = new(FakeOperatorLister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha1lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha1lister.go new file mode 100644 index 0000000000..eee7e35bd0 --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha1lister.go @@ -0,0 +1,142 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + v1alpha1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" +) + +type FakeOperatorsV1alpha1Lister struct { + ClusterServiceVersionListerStub func() v1alpha1.ClusterServiceVersionLister + clusterServiceVersionListerMutex sync.RWMutex + clusterServiceVersionListerArgsForCall []struct { + } + clusterServiceVersionListerReturns struct { + result1 v1alpha1.ClusterServiceVersionLister + } + clusterServiceVersionListerReturnsOnCall map[int]struct { + result1 v1alpha1.ClusterServiceVersionLister + } + RegisterClusterServiceVersionListerStub func(string, v1alpha1.ClusterServiceVersionLister) + registerClusterServiceVersionListerMutex sync.RWMutex + registerClusterServiceVersionListerArgsForCall []struct { + arg1 string + arg2 v1alpha1.ClusterServiceVersionLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeOperatorsV1alpha1Lister) ClusterServiceVersionLister() v1alpha1.ClusterServiceVersionLister { + fake.clusterServiceVersionListerMutex.Lock() + ret, specificReturn := fake.clusterServiceVersionListerReturnsOnCall[len(fake.clusterServiceVersionListerArgsForCall)] + fake.clusterServiceVersionListerArgsForCall = append(fake.clusterServiceVersionListerArgsForCall, struct { + }{}) + fake.recordInvocation("ClusterServiceVersionLister", []interface{}{}) + fake.clusterServiceVersionListerMutex.Unlock() + if fake.ClusterServiceVersionListerStub != nil { + return fake.ClusterServiceVersionListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.clusterServiceVersionListerReturns + return fakeReturns.result1 +} + +func (fake *FakeOperatorsV1alpha1Lister) ClusterServiceVersionListerCallCount() int { + fake.clusterServiceVersionListerMutex.RLock() + defer fake.clusterServiceVersionListerMutex.RUnlock() + return len(fake.clusterServiceVersionListerArgsForCall) +} + +func (fake *FakeOperatorsV1alpha1Lister) ClusterServiceVersionListerCalls(stub func() v1alpha1.ClusterServiceVersionLister) { + fake.clusterServiceVersionListerMutex.Lock() + defer fake.clusterServiceVersionListerMutex.Unlock() + fake.ClusterServiceVersionListerStub = stub +} + +func (fake *FakeOperatorsV1alpha1Lister) ClusterServiceVersionListerReturns(result1 v1alpha1.ClusterServiceVersionLister) { + fake.clusterServiceVersionListerMutex.Lock() + defer fake.clusterServiceVersionListerMutex.Unlock() + fake.ClusterServiceVersionListerStub = nil + fake.clusterServiceVersionListerReturns = struct { + result1 v1alpha1.ClusterServiceVersionLister + }{result1} +} + +func (fake *FakeOperatorsV1alpha1Lister) ClusterServiceVersionListerReturnsOnCall(i int, result1 v1alpha1.ClusterServiceVersionLister) { + fake.clusterServiceVersionListerMutex.Lock() + defer fake.clusterServiceVersionListerMutex.Unlock() + fake.ClusterServiceVersionListerStub = nil + if fake.clusterServiceVersionListerReturnsOnCall == nil { + fake.clusterServiceVersionListerReturnsOnCall = make(map[int]struct { + result1 v1alpha1.ClusterServiceVersionLister + }) + } + fake.clusterServiceVersionListerReturnsOnCall[i] = struct { + result1 v1alpha1.ClusterServiceVersionLister + }{result1} +} + +func (fake *FakeOperatorsV1alpha1Lister) RegisterClusterServiceVersionLister(arg1 string, arg2 v1alpha1.ClusterServiceVersionLister) { + fake.registerClusterServiceVersionListerMutex.Lock() + fake.registerClusterServiceVersionListerArgsForCall = append(fake.registerClusterServiceVersionListerArgsForCall, struct { + arg1 string + arg2 v1alpha1.ClusterServiceVersionLister + }{arg1, arg2}) + fake.recordInvocation("RegisterClusterServiceVersionLister", []interface{}{arg1, arg2}) + fake.registerClusterServiceVersionListerMutex.Unlock() + if fake.RegisterClusterServiceVersionListerStub != nil { + fake.RegisterClusterServiceVersionListerStub(arg1, arg2) + } +} + +func (fake *FakeOperatorsV1alpha1Lister) RegisterClusterServiceVersionListerCallCount() int { + fake.registerClusterServiceVersionListerMutex.RLock() + defer fake.registerClusterServiceVersionListerMutex.RUnlock() + return len(fake.registerClusterServiceVersionListerArgsForCall) +} + +func (fake *FakeOperatorsV1alpha1Lister) RegisterClusterServiceVersionListerCalls(stub func(string, v1alpha1.ClusterServiceVersionLister)) { + fake.registerClusterServiceVersionListerMutex.Lock() + defer fake.registerClusterServiceVersionListerMutex.Unlock() + fake.RegisterClusterServiceVersionListerStub = stub +} + +func (fake *FakeOperatorsV1alpha1Lister) RegisterClusterServiceVersionListerArgsForCall(i int) (string, v1alpha1.ClusterServiceVersionLister) { + fake.registerClusterServiceVersionListerMutex.RLock() + defer fake.registerClusterServiceVersionListerMutex.RUnlock() + argsForCall := fake.registerClusterServiceVersionListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeOperatorsV1alpha1Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.clusterServiceVersionListerMutex.RLock() + defer fake.clusterServiceVersionListerMutex.RUnlock() + fake.registerClusterServiceVersionListerMutex.RLock() + defer fake.registerClusterServiceVersionListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeOperatorsV1alpha1Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.OperatorsV1alpha1Lister = new(FakeOperatorsV1alpha1Lister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha2lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha2lister.go new file mode 100644 index 0000000000..38ddf8c6ce --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_operators_v1alpha2lister.go @@ -0,0 +1,142 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + v1alpha2 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha2" + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" +) + +type FakeOperatorsV1alpha2Lister struct { + OperatorGroupListerStub func() v1alpha2.OperatorGroupLister + operatorGroupListerMutex sync.RWMutex + operatorGroupListerArgsForCall []struct { + } + operatorGroupListerReturns struct { + result1 v1alpha2.OperatorGroupLister + } + operatorGroupListerReturnsOnCall map[int]struct { + result1 v1alpha2.OperatorGroupLister + } + RegisterOperatorGroupListerStub func(string, v1alpha2.OperatorGroupLister) + registerOperatorGroupListerMutex sync.RWMutex + registerOperatorGroupListerArgsForCall []struct { + arg1 string + arg2 v1alpha2.OperatorGroupLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeOperatorsV1alpha2Lister) OperatorGroupLister() v1alpha2.OperatorGroupLister { + fake.operatorGroupListerMutex.Lock() + ret, specificReturn := fake.operatorGroupListerReturnsOnCall[len(fake.operatorGroupListerArgsForCall)] + fake.operatorGroupListerArgsForCall = append(fake.operatorGroupListerArgsForCall, struct { + }{}) + fake.recordInvocation("OperatorGroupLister", []interface{}{}) + fake.operatorGroupListerMutex.Unlock() + if fake.OperatorGroupListerStub != nil { + return fake.OperatorGroupListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.operatorGroupListerReturns + return fakeReturns.result1 +} + +func (fake *FakeOperatorsV1alpha2Lister) OperatorGroupListerCallCount() int { + fake.operatorGroupListerMutex.RLock() + defer fake.operatorGroupListerMutex.RUnlock() + return len(fake.operatorGroupListerArgsForCall) +} + +func (fake *FakeOperatorsV1alpha2Lister) OperatorGroupListerCalls(stub func() v1alpha2.OperatorGroupLister) { + fake.operatorGroupListerMutex.Lock() + defer fake.operatorGroupListerMutex.Unlock() + fake.OperatorGroupListerStub = stub +} + +func (fake *FakeOperatorsV1alpha2Lister) OperatorGroupListerReturns(result1 v1alpha2.OperatorGroupLister) { + fake.operatorGroupListerMutex.Lock() + defer fake.operatorGroupListerMutex.Unlock() + fake.OperatorGroupListerStub = nil + fake.operatorGroupListerReturns = struct { + result1 v1alpha2.OperatorGroupLister + }{result1} +} + +func (fake *FakeOperatorsV1alpha2Lister) OperatorGroupListerReturnsOnCall(i int, result1 v1alpha2.OperatorGroupLister) { + fake.operatorGroupListerMutex.Lock() + defer fake.operatorGroupListerMutex.Unlock() + fake.OperatorGroupListerStub = nil + if fake.operatorGroupListerReturnsOnCall == nil { + fake.operatorGroupListerReturnsOnCall = make(map[int]struct { + result1 v1alpha2.OperatorGroupLister + }) + } + fake.operatorGroupListerReturnsOnCall[i] = struct { + result1 v1alpha2.OperatorGroupLister + }{result1} +} + +func (fake *FakeOperatorsV1alpha2Lister) RegisterOperatorGroupLister(arg1 string, arg2 v1alpha2.OperatorGroupLister) { + fake.registerOperatorGroupListerMutex.Lock() + fake.registerOperatorGroupListerArgsForCall = append(fake.registerOperatorGroupListerArgsForCall, struct { + arg1 string + arg2 v1alpha2.OperatorGroupLister + }{arg1, arg2}) + fake.recordInvocation("RegisterOperatorGroupLister", []interface{}{arg1, arg2}) + fake.registerOperatorGroupListerMutex.Unlock() + if fake.RegisterOperatorGroupListerStub != nil { + fake.RegisterOperatorGroupListerStub(arg1, arg2) + } +} + +func (fake *FakeOperatorsV1alpha2Lister) RegisterOperatorGroupListerCallCount() int { + fake.registerOperatorGroupListerMutex.RLock() + defer fake.registerOperatorGroupListerMutex.RUnlock() + return len(fake.registerOperatorGroupListerArgsForCall) +} + +func (fake *FakeOperatorsV1alpha2Lister) RegisterOperatorGroupListerCalls(stub func(string, v1alpha2.OperatorGroupLister)) { + fake.registerOperatorGroupListerMutex.Lock() + defer fake.registerOperatorGroupListerMutex.Unlock() + fake.RegisterOperatorGroupListerStub = stub +} + +func (fake *FakeOperatorsV1alpha2Lister) RegisterOperatorGroupListerArgsForCall(i int) (string, v1alpha2.OperatorGroupLister) { + fake.registerOperatorGroupListerMutex.RLock() + defer fake.registerOperatorGroupListerMutex.RUnlock() + argsForCall := fake.registerOperatorGroupListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeOperatorsV1alpha2Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.operatorGroupListerMutex.RLock() + defer fake.operatorGroupListerMutex.RUnlock() + fake.registerOperatorGroupListerMutex.RLock() + defer fake.registerOperatorGroupListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeOperatorsV1alpha2Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.OperatorsV1alpha2Lister = new(FakeOperatorsV1alpha2Lister) diff --git a/pkg/lib/operatorlister/operatorlisterfakes/fake_rbac_v1lister.go b/pkg/lib/operatorlister/operatorlisterfakes/fake_rbac_v1lister.go new file mode 100644 index 0000000000..171d5d7b9e --- /dev/null +++ b/pkg/lib/operatorlister/operatorlisterfakes/fake_rbac_v1lister.go @@ -0,0 +1,450 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package operatorlisterfakes + +import ( + sync "sync" + + operatorlister "github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister" + v1 "k8s.io/client-go/listers/rbac/v1" +) + +type FakeRbacV1Lister struct { + ClusterRoleBindingListerStub func() v1.ClusterRoleBindingLister + clusterRoleBindingListerMutex sync.RWMutex + clusterRoleBindingListerArgsForCall []struct { + } + clusterRoleBindingListerReturns struct { + result1 v1.ClusterRoleBindingLister + } + clusterRoleBindingListerReturnsOnCall map[int]struct { + result1 v1.ClusterRoleBindingLister + } + ClusterRoleListerStub func() v1.ClusterRoleLister + clusterRoleListerMutex sync.RWMutex + clusterRoleListerArgsForCall []struct { + } + clusterRoleListerReturns struct { + result1 v1.ClusterRoleLister + } + clusterRoleListerReturnsOnCall map[int]struct { + result1 v1.ClusterRoleLister + } + RegisterClusterRoleBindingListerStub func(v1.ClusterRoleBindingLister) + registerClusterRoleBindingListerMutex sync.RWMutex + registerClusterRoleBindingListerArgsForCall []struct { + arg1 v1.ClusterRoleBindingLister + } + RegisterClusterRoleListerStub func(v1.ClusterRoleLister) + registerClusterRoleListerMutex sync.RWMutex + registerClusterRoleListerArgsForCall []struct { + arg1 v1.ClusterRoleLister + } + RegisterRoleBindingListerStub func(string, v1.RoleBindingLister) + registerRoleBindingListerMutex sync.RWMutex + registerRoleBindingListerArgsForCall []struct { + arg1 string + arg2 v1.RoleBindingLister + } + RegisterRoleListerStub func(string, v1.RoleLister) + registerRoleListerMutex sync.RWMutex + registerRoleListerArgsForCall []struct { + arg1 string + arg2 v1.RoleLister + } + RoleBindingListerStub func() v1.RoleBindingLister + roleBindingListerMutex sync.RWMutex + roleBindingListerArgsForCall []struct { + } + roleBindingListerReturns struct { + result1 v1.RoleBindingLister + } + roleBindingListerReturnsOnCall map[int]struct { + result1 v1.RoleBindingLister + } + RoleListerStub func() v1.RoleLister + roleListerMutex sync.RWMutex + roleListerArgsForCall []struct { + } + roleListerReturns struct { + result1 v1.RoleLister + } + roleListerReturnsOnCall map[int]struct { + result1 v1.RoleLister + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeRbacV1Lister) ClusterRoleBindingLister() v1.ClusterRoleBindingLister { + fake.clusterRoleBindingListerMutex.Lock() + ret, specificReturn := fake.clusterRoleBindingListerReturnsOnCall[len(fake.clusterRoleBindingListerArgsForCall)] + fake.clusterRoleBindingListerArgsForCall = append(fake.clusterRoleBindingListerArgsForCall, struct { + }{}) + fake.recordInvocation("ClusterRoleBindingLister", []interface{}{}) + fake.clusterRoleBindingListerMutex.Unlock() + if fake.ClusterRoleBindingListerStub != nil { + return fake.ClusterRoleBindingListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.clusterRoleBindingListerReturns + return fakeReturns.result1 +} + +func (fake *FakeRbacV1Lister) ClusterRoleBindingListerCallCount() int { + fake.clusterRoleBindingListerMutex.RLock() + defer fake.clusterRoleBindingListerMutex.RUnlock() + return len(fake.clusterRoleBindingListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) ClusterRoleBindingListerCalls(stub func() v1.ClusterRoleBindingLister) { + fake.clusterRoleBindingListerMutex.Lock() + defer fake.clusterRoleBindingListerMutex.Unlock() + fake.ClusterRoleBindingListerStub = stub +} + +func (fake *FakeRbacV1Lister) ClusterRoleBindingListerReturns(result1 v1.ClusterRoleBindingLister) { + fake.clusterRoleBindingListerMutex.Lock() + defer fake.clusterRoleBindingListerMutex.Unlock() + fake.ClusterRoleBindingListerStub = nil + fake.clusterRoleBindingListerReturns = struct { + result1 v1.ClusterRoleBindingLister + }{result1} +} + +func (fake *FakeRbacV1Lister) ClusterRoleBindingListerReturnsOnCall(i int, result1 v1.ClusterRoleBindingLister) { + fake.clusterRoleBindingListerMutex.Lock() + defer fake.clusterRoleBindingListerMutex.Unlock() + fake.ClusterRoleBindingListerStub = nil + if fake.clusterRoleBindingListerReturnsOnCall == nil { + fake.clusterRoleBindingListerReturnsOnCall = make(map[int]struct { + result1 v1.ClusterRoleBindingLister + }) + } + fake.clusterRoleBindingListerReturnsOnCall[i] = struct { + result1 v1.ClusterRoleBindingLister + }{result1} +} + +func (fake *FakeRbacV1Lister) ClusterRoleLister() v1.ClusterRoleLister { + fake.clusterRoleListerMutex.Lock() + ret, specificReturn := fake.clusterRoleListerReturnsOnCall[len(fake.clusterRoleListerArgsForCall)] + fake.clusterRoleListerArgsForCall = append(fake.clusterRoleListerArgsForCall, struct { + }{}) + fake.recordInvocation("ClusterRoleLister", []interface{}{}) + fake.clusterRoleListerMutex.Unlock() + if fake.ClusterRoleListerStub != nil { + return fake.ClusterRoleListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.clusterRoleListerReturns + return fakeReturns.result1 +} + +func (fake *FakeRbacV1Lister) ClusterRoleListerCallCount() int { + fake.clusterRoleListerMutex.RLock() + defer fake.clusterRoleListerMutex.RUnlock() + return len(fake.clusterRoleListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) ClusterRoleListerCalls(stub func() v1.ClusterRoleLister) { + fake.clusterRoleListerMutex.Lock() + defer fake.clusterRoleListerMutex.Unlock() + fake.ClusterRoleListerStub = stub +} + +func (fake *FakeRbacV1Lister) ClusterRoleListerReturns(result1 v1.ClusterRoleLister) { + fake.clusterRoleListerMutex.Lock() + defer fake.clusterRoleListerMutex.Unlock() + fake.ClusterRoleListerStub = nil + fake.clusterRoleListerReturns = struct { + result1 v1.ClusterRoleLister + }{result1} +} + +func (fake *FakeRbacV1Lister) ClusterRoleListerReturnsOnCall(i int, result1 v1.ClusterRoleLister) { + fake.clusterRoleListerMutex.Lock() + defer fake.clusterRoleListerMutex.Unlock() + fake.ClusterRoleListerStub = nil + if fake.clusterRoleListerReturnsOnCall == nil { + fake.clusterRoleListerReturnsOnCall = make(map[int]struct { + result1 v1.ClusterRoleLister + }) + } + fake.clusterRoleListerReturnsOnCall[i] = struct { + result1 v1.ClusterRoleLister + }{result1} +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleBindingLister(arg1 v1.ClusterRoleBindingLister) { + fake.registerClusterRoleBindingListerMutex.Lock() + fake.registerClusterRoleBindingListerArgsForCall = append(fake.registerClusterRoleBindingListerArgsForCall, struct { + arg1 v1.ClusterRoleBindingLister + }{arg1}) + fake.recordInvocation("RegisterClusterRoleBindingLister", []interface{}{arg1}) + fake.registerClusterRoleBindingListerMutex.Unlock() + if fake.RegisterClusterRoleBindingListerStub != nil { + fake.RegisterClusterRoleBindingListerStub(arg1) + } +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleBindingListerCallCount() int { + fake.registerClusterRoleBindingListerMutex.RLock() + defer fake.registerClusterRoleBindingListerMutex.RUnlock() + return len(fake.registerClusterRoleBindingListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleBindingListerCalls(stub func(v1.ClusterRoleBindingLister)) { + fake.registerClusterRoleBindingListerMutex.Lock() + defer fake.registerClusterRoleBindingListerMutex.Unlock() + fake.RegisterClusterRoleBindingListerStub = stub +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleBindingListerArgsForCall(i int) v1.ClusterRoleBindingLister { + fake.registerClusterRoleBindingListerMutex.RLock() + defer fake.registerClusterRoleBindingListerMutex.RUnlock() + argsForCall := fake.registerClusterRoleBindingListerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleLister(arg1 v1.ClusterRoleLister) { + fake.registerClusterRoleListerMutex.Lock() + fake.registerClusterRoleListerArgsForCall = append(fake.registerClusterRoleListerArgsForCall, struct { + arg1 v1.ClusterRoleLister + }{arg1}) + fake.recordInvocation("RegisterClusterRoleLister", []interface{}{arg1}) + fake.registerClusterRoleListerMutex.Unlock() + if fake.RegisterClusterRoleListerStub != nil { + fake.RegisterClusterRoleListerStub(arg1) + } +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleListerCallCount() int { + fake.registerClusterRoleListerMutex.RLock() + defer fake.registerClusterRoleListerMutex.RUnlock() + return len(fake.registerClusterRoleListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleListerCalls(stub func(v1.ClusterRoleLister)) { + fake.registerClusterRoleListerMutex.Lock() + defer fake.registerClusterRoleListerMutex.Unlock() + fake.RegisterClusterRoleListerStub = stub +} + +func (fake *FakeRbacV1Lister) RegisterClusterRoleListerArgsForCall(i int) v1.ClusterRoleLister { + fake.registerClusterRoleListerMutex.RLock() + defer fake.registerClusterRoleListerMutex.RUnlock() + argsForCall := fake.registerClusterRoleListerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeRbacV1Lister) RegisterRoleBindingLister(arg1 string, arg2 v1.RoleBindingLister) { + fake.registerRoleBindingListerMutex.Lock() + fake.registerRoleBindingListerArgsForCall = append(fake.registerRoleBindingListerArgsForCall, struct { + arg1 string + arg2 v1.RoleBindingLister + }{arg1, arg2}) + fake.recordInvocation("RegisterRoleBindingLister", []interface{}{arg1, arg2}) + fake.registerRoleBindingListerMutex.Unlock() + if fake.RegisterRoleBindingListerStub != nil { + fake.RegisterRoleBindingListerStub(arg1, arg2) + } +} + +func (fake *FakeRbacV1Lister) RegisterRoleBindingListerCallCount() int { + fake.registerRoleBindingListerMutex.RLock() + defer fake.registerRoleBindingListerMutex.RUnlock() + return len(fake.registerRoleBindingListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) RegisterRoleBindingListerCalls(stub func(string, v1.RoleBindingLister)) { + fake.registerRoleBindingListerMutex.Lock() + defer fake.registerRoleBindingListerMutex.Unlock() + fake.RegisterRoleBindingListerStub = stub +} + +func (fake *FakeRbacV1Lister) RegisterRoleBindingListerArgsForCall(i int) (string, v1.RoleBindingLister) { + fake.registerRoleBindingListerMutex.RLock() + defer fake.registerRoleBindingListerMutex.RUnlock() + argsForCall := fake.registerRoleBindingListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeRbacV1Lister) RegisterRoleLister(arg1 string, arg2 v1.RoleLister) { + fake.registerRoleListerMutex.Lock() + fake.registerRoleListerArgsForCall = append(fake.registerRoleListerArgsForCall, struct { + arg1 string + arg2 v1.RoleLister + }{arg1, arg2}) + fake.recordInvocation("RegisterRoleLister", []interface{}{arg1, arg2}) + fake.registerRoleListerMutex.Unlock() + if fake.RegisterRoleListerStub != nil { + fake.RegisterRoleListerStub(arg1, arg2) + } +} + +func (fake *FakeRbacV1Lister) RegisterRoleListerCallCount() int { + fake.registerRoleListerMutex.RLock() + defer fake.registerRoleListerMutex.RUnlock() + return len(fake.registerRoleListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) RegisterRoleListerCalls(stub func(string, v1.RoleLister)) { + fake.registerRoleListerMutex.Lock() + defer fake.registerRoleListerMutex.Unlock() + fake.RegisterRoleListerStub = stub +} + +func (fake *FakeRbacV1Lister) RegisterRoleListerArgsForCall(i int) (string, v1.RoleLister) { + fake.registerRoleListerMutex.RLock() + defer fake.registerRoleListerMutex.RUnlock() + argsForCall := fake.registerRoleListerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeRbacV1Lister) RoleBindingLister() v1.RoleBindingLister { + fake.roleBindingListerMutex.Lock() + ret, specificReturn := fake.roleBindingListerReturnsOnCall[len(fake.roleBindingListerArgsForCall)] + fake.roleBindingListerArgsForCall = append(fake.roleBindingListerArgsForCall, struct { + }{}) + fake.recordInvocation("RoleBindingLister", []interface{}{}) + fake.roleBindingListerMutex.Unlock() + if fake.RoleBindingListerStub != nil { + return fake.RoleBindingListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.roleBindingListerReturns + return fakeReturns.result1 +} + +func (fake *FakeRbacV1Lister) RoleBindingListerCallCount() int { + fake.roleBindingListerMutex.RLock() + defer fake.roleBindingListerMutex.RUnlock() + return len(fake.roleBindingListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) RoleBindingListerCalls(stub func() v1.RoleBindingLister) { + fake.roleBindingListerMutex.Lock() + defer fake.roleBindingListerMutex.Unlock() + fake.RoleBindingListerStub = stub +} + +func (fake *FakeRbacV1Lister) RoleBindingListerReturns(result1 v1.RoleBindingLister) { + fake.roleBindingListerMutex.Lock() + defer fake.roleBindingListerMutex.Unlock() + fake.RoleBindingListerStub = nil + fake.roleBindingListerReturns = struct { + result1 v1.RoleBindingLister + }{result1} +} + +func (fake *FakeRbacV1Lister) RoleBindingListerReturnsOnCall(i int, result1 v1.RoleBindingLister) { + fake.roleBindingListerMutex.Lock() + defer fake.roleBindingListerMutex.Unlock() + fake.RoleBindingListerStub = nil + if fake.roleBindingListerReturnsOnCall == nil { + fake.roleBindingListerReturnsOnCall = make(map[int]struct { + result1 v1.RoleBindingLister + }) + } + fake.roleBindingListerReturnsOnCall[i] = struct { + result1 v1.RoleBindingLister + }{result1} +} + +func (fake *FakeRbacV1Lister) RoleLister() v1.RoleLister { + fake.roleListerMutex.Lock() + ret, specificReturn := fake.roleListerReturnsOnCall[len(fake.roleListerArgsForCall)] + fake.roleListerArgsForCall = append(fake.roleListerArgsForCall, struct { + }{}) + fake.recordInvocation("RoleLister", []interface{}{}) + fake.roleListerMutex.Unlock() + if fake.RoleListerStub != nil { + return fake.RoleListerStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.roleListerReturns + return fakeReturns.result1 +} + +func (fake *FakeRbacV1Lister) RoleListerCallCount() int { + fake.roleListerMutex.RLock() + defer fake.roleListerMutex.RUnlock() + return len(fake.roleListerArgsForCall) +} + +func (fake *FakeRbacV1Lister) RoleListerCalls(stub func() v1.RoleLister) { + fake.roleListerMutex.Lock() + defer fake.roleListerMutex.Unlock() + fake.RoleListerStub = stub +} + +func (fake *FakeRbacV1Lister) RoleListerReturns(result1 v1.RoleLister) { + fake.roleListerMutex.Lock() + defer fake.roleListerMutex.Unlock() + fake.RoleListerStub = nil + fake.roleListerReturns = struct { + result1 v1.RoleLister + }{result1} +} + +func (fake *FakeRbacV1Lister) RoleListerReturnsOnCall(i int, result1 v1.RoleLister) { + fake.roleListerMutex.Lock() + defer fake.roleListerMutex.Unlock() + fake.RoleListerStub = nil + if fake.roleListerReturnsOnCall == nil { + fake.roleListerReturnsOnCall = make(map[int]struct { + result1 v1.RoleLister + }) + } + fake.roleListerReturnsOnCall[i] = struct { + result1 v1.RoleLister + }{result1} +} + +func (fake *FakeRbacV1Lister) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.clusterRoleBindingListerMutex.RLock() + defer fake.clusterRoleBindingListerMutex.RUnlock() + fake.clusterRoleListerMutex.RLock() + defer fake.clusterRoleListerMutex.RUnlock() + fake.registerClusterRoleBindingListerMutex.RLock() + defer fake.registerClusterRoleBindingListerMutex.RUnlock() + fake.registerClusterRoleListerMutex.RLock() + defer fake.registerClusterRoleListerMutex.RUnlock() + fake.registerRoleBindingListerMutex.RLock() + defer fake.registerRoleBindingListerMutex.RUnlock() + fake.registerRoleListerMutex.RLock() + defer fake.registerRoleListerMutex.RUnlock() + fake.roleBindingListerMutex.RLock() + defer fake.roleBindingListerMutex.RUnlock() + fake.roleListerMutex.RLock() + defer fake.roleListerMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeRbacV1Lister) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ operatorlister.RbacV1Lister = new(FakeRbacV1Lister) diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go index d1c277e2fa..fc72d118d6 100644 --- a/pkg/metrics/metrics.go +++ b/pkg/metrics/metrics.go @@ -1,9 +1,12 @@ package metrics import ( - "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned" "github.com/prometheus/client_golang/prometheus" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + + "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned" + v1alpha1 "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/listers/operators/v1alpha1" ) // TODO(alecmerdler): Can we use this to emit Kubernetes events? @@ -12,19 +15,19 @@ type MetricsProvider interface { } type metricsCSV struct { - client versioned.Interface + lister v1alpha1.ClusterServiceVersionLister } -func NewMetricsCSV(client versioned.Interface) MetricsProvider { - return &metricsCSV{client} +func NewMetricsCSV(lister v1alpha1.ClusterServiceVersionLister) MetricsProvider { + return &metricsCSV{lister} } func (m *metricsCSV) HandleMetrics() error { - cList, err := m.client.OperatorsV1alpha1().ClusterServiceVersions(metav1.NamespaceAll).List(metav1.ListOptions{}) + cList, err := m.lister.List(labels.Everything()) if err != nil { return err } - csvCount.Set(float64(len(cList.Items))) + csvCount.Set(float64(len(cList))) return nil } diff --git a/scripts/generate_mocks.sh b/scripts/generate_mocks.sh index f612c5c921..34f5252e50 100644 --- a/scripts/generate_mocks.sh +++ b/scripts/generate_mocks.sh @@ -6,4 +6,6 @@ go install ./vendor/github.com/maxbrunsfeld/counterfeiter # generate fakes and mocks go generate ./pkg/... +counterfeiter -o ./pkg/fakes/client-go/listers/fake_v1_service_account_lister.go ./vendor/k8s.io/client-go/listers/core/v1 ServiceAccountLister +counterfeiter -o ./pkg/fakes/client-go/listers/fake_v1_service_account_namespace_lister.go ./vendor/k8s.io/client-go/listers/core/v1 ServiceAccountNamespaceLister mockgen -source ./pkg/lib/operatorclient/client.go -destination ./pkg/lib/operatorclient/mock_client.go -package operatorclient diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/interface.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/interface.go new file mode 100644 index 0000000000..7b48c57ca4 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/interface.go @@ -0,0 +1,46 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package apiextensions + +import ( + v1beta1 "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1" + internalinterfaces "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces" +) + +// Interface provides access to each of this group's versions. +type Interface interface { + // V1beta1 provides access to shared informers for resources in V1beta1. + V1beta1() v1beta1.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} +} + +// V1beta1 returns a new v1beta1.Interface. +func (g *group) V1beta1() v1beta1.Interface { + return v1beta1.New(g.factory, g.namespace, g.tweakListOptions) +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/customresourcedefinition.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/customresourcedefinition.go new file mode 100644 index 0000000000..589b4b20ca --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/customresourcedefinition.go @@ -0,0 +1,88 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1beta1 + +import ( + time "time" + + apiextensions_v1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" + clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset" + internalinterfaces "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces" + v1beta1 "k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1" + 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" +) + +// CustomResourceDefinitionInformer provides access to a shared informer and lister for +// CustomResourceDefinitions. +type CustomResourceDefinitionInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1beta1.CustomResourceDefinitionLister +} + +type customResourceDefinitionInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewCustomResourceDefinitionInformer constructs a new informer for CustomResourceDefinition 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 NewCustomResourceDefinitionInformer(client clientset.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredCustomResourceDefinitionInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredCustomResourceDefinitionInformer constructs a new informer for CustomResourceDefinition 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 NewFilteredCustomResourceDefinitionInformer(client clientset.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.ApiextensionsV1beta1().CustomResourceDefinitions().List(options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ApiextensionsV1beta1().CustomResourceDefinitions().Watch(options) + }, + }, + &apiextensions_v1beta1.CustomResourceDefinition{}, + resyncPeriod, + indexers, + ) +} + +func (f *customResourceDefinitionInformer) defaultInformer(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredCustomResourceDefinitionInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *customResourceDefinitionInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apiextensions_v1beta1.CustomResourceDefinition{}, f.defaultInformer) +} + +func (f *customResourceDefinitionInformer) Lister() v1beta1.CustomResourceDefinitionLister { + return v1beta1.NewCustomResourceDefinitionLister(f.Informer().GetIndexer()) +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/interface.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/interface.go new file mode 100644 index 0000000000..f78edbb593 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1/interface.go @@ -0,0 +1,45 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1beta1 + +import ( + internalinterfaces "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // CustomResourceDefinitions returns a CustomResourceDefinitionInformer. + CustomResourceDefinitions() CustomResourceDefinitionInformer +} + +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} +} + +// CustomResourceDefinitions returns a CustomResourceDefinitionInformer. +func (v *version) CustomResourceDefinitions() CustomResourceDefinitionInformer { + return &customResourceDefinitionInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/factory.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/factory.go new file mode 100644 index 0000000000..94d039c729 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/factory.go @@ -0,0 +1,180 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package externalversions + +import ( + reflect "reflect" + sync "sync" + time "time" + + clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset" + apiextensions "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions" + internalinterfaces "k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" + cache "k8s.io/client-go/tools/cache" +) + +// SharedInformerOption defines the functional option type for SharedInformerFactory. +type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory + +type sharedInformerFactory struct { + client clientset.Interface + namespace string + tweakListOptions internalinterfaces.TweakListOptionsFunc + lock sync.Mutex + defaultResync time.Duration + customResync map[reflect.Type]time.Duration + + informers map[reflect.Type]cache.SharedIndexInformer + // startedInformers is used for tracking which informers have been started. + // This allows Start() to be called multiple times safely. + startedInformers map[reflect.Type]bool +} + +// WithCustomResyncConfig sets a custom resync period for the specified informer types. +func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + for k, v := range resyncConfig { + factory.customResync[reflect.TypeOf(k)] = v + } + return factory + } +} + +// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory. +func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.tweakListOptions = tweakListOptions + return factory + } +} + +// WithNamespace limits the SharedInformerFactory to the specified namespace. +func WithNamespace(namespace string) SharedInformerOption { + return func(factory *sharedInformerFactory) *sharedInformerFactory { + factory.namespace = namespace + return factory + } +} + +// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces. +func NewSharedInformerFactory(client clientset.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 clientset.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 clientset.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory { + factory := &sharedInformerFactory{ + client: client, + namespace: v1.NamespaceAll, + defaultResync: defaultResync, + informers: make(map[reflect.Type]cache.SharedIndexInformer), + startedInformers: make(map[reflect.Type]bool), + customResync: make(map[reflect.Type]time.Duration), + } + + // Apply all options + for _, opt := range options { + factory = opt(factory) + } + + return factory +} + +// Start initializes all requested informers. +func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) { + f.lock.Lock() + defer f.lock.Unlock() + + for informerType, informer := range f.informers { + if !f.startedInformers[informerType] { + go informer.Run(stopCh) + f.startedInformers[informerType] = true + } + } +} + +// WaitForCacheSync waits for all started informers' cache were synced. +func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool { + informers := func() map[reflect.Type]cache.SharedIndexInformer { + f.lock.Lock() + defer f.lock.Unlock() + + informers := map[reflect.Type]cache.SharedIndexInformer{} + for informerType, informer := range f.informers { + if f.startedInformers[informerType] { + informers[informerType] = informer + } + } + return informers + }() + + res := map[reflect.Type]bool{} + for informType, informer := range informers { + res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced) + } + return res +} + +// InternalInformerFor returns the SharedIndexInformer for obj using an internal +// client. +func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer { + f.lock.Lock() + defer f.lock.Unlock() + + informerType := reflect.TypeOf(obj) + informer, exists := f.informers[informerType] + if exists { + return informer + } + + resyncPeriod, exists := f.customResync[informerType] + if !exists { + resyncPeriod = f.defaultResync + } + + informer = newFunc(f.client, resyncPeriod) + f.informers[informerType] = informer + + return informer +} + +// SharedInformerFactory provides shared informers for resources in all known +// API group versions. +type SharedInformerFactory interface { + internalinterfaces.SharedInformerFactory + ForResource(resource schema.GroupVersionResource) (GenericInformer, error) + WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool + + Apiextensions() apiextensions.Interface +} + +func (f *sharedInformerFactory) Apiextensions() apiextensions.Interface { + return apiextensions.New(f, f.namespace, f.tweakListOptions) +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/generic.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/generic.go new file mode 100644 index 0000000000..da8a2ab0c6 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/generic.go @@ -0,0 +1,62 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package externalversions + +import ( + "fmt" + + v1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" + 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=apiextensions.k8s.io, Version=v1beta1 + case v1beta1.SchemeGroupVersion.WithResource("customresourcedefinitions"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Apiextensions().V1beta1().CustomResourceDefinitions().Informer()}, nil + + } + + return nil, fmt.Errorf("no informer found for %v", resource) +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go new file mode 100644 index 0000000000..3b17f5a1a5 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go @@ -0,0 +1,38 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package internalinterfaces + +import ( + time "time" + + clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + cache "k8s.io/client-go/tools/cache" +) + +type NewInformerFunc func(clientset.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 +} + +type TweakListOptionsFunc func(*v1.ListOptions) diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/customresourcedefinition.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/customresourcedefinition.go new file mode 100644 index 0000000000..87633217b0 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/customresourcedefinition.go @@ -0,0 +1,65 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1beta1 + +import ( + v1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// CustomResourceDefinitionLister helps list CustomResourceDefinitions. +type CustomResourceDefinitionLister interface { + // List lists all CustomResourceDefinitions in the indexer. + List(selector labels.Selector) (ret []*v1beta1.CustomResourceDefinition, err error) + // Get retrieves the CustomResourceDefinition from the index for a given name. + Get(name string) (*v1beta1.CustomResourceDefinition, error) + CustomResourceDefinitionListerExpansion +} + +// customResourceDefinitionLister implements the CustomResourceDefinitionLister interface. +type customResourceDefinitionLister struct { + indexer cache.Indexer +} + +// NewCustomResourceDefinitionLister returns a new CustomResourceDefinitionLister. +func NewCustomResourceDefinitionLister(indexer cache.Indexer) CustomResourceDefinitionLister { + return &customResourceDefinitionLister{indexer: indexer} +} + +// List lists all CustomResourceDefinitions in the indexer. +func (s *customResourceDefinitionLister) List(selector labels.Selector) (ret []*v1beta1.CustomResourceDefinition, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1beta1.CustomResourceDefinition)) + }) + return ret, err +} + +// Get retrieves the CustomResourceDefinition from the index for a given name. +func (s *customResourceDefinitionLister) Get(name string) (*v1beta1.CustomResourceDefinition, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1beta1.Resource("customresourcedefinition"), name) + } + return obj.(*v1beta1.CustomResourceDefinition), nil +} diff --git a/vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/expansion_generated.go b/vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/expansion_generated.go new file mode 100644 index 0000000000..429782deb0 --- /dev/null +++ b/vendor/k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1/expansion_generated.go @@ -0,0 +1,23 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1beta1 + +// CustomResourceDefinitionListerExpansion allows custom methods to be added to +// CustomResourceDefinitionLister. +type CustomResourceDefinitionListerExpansion interface{} diff --git a/vendor/modules.txt b/vendor/modules.txt index 9820527c1d..5cec667152 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -268,14 +268,19 @@ k8s.io/api/admission/v1beta1 # k8s.io/apiextensions-apiserver v0.0.0-20180905004947-16750353bf97 k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/scheme k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1 +k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset +k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/v1beta1 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation k8s.io/apiextensions-apiserver/pkg/apiserver/validation k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/fake +k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions +k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/internalinterfaces k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1 k8s.io/apiextensions-apiserver/pkg/features k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1/fake +k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions/apiextensions/v1beta1 # k8s.io/apimachinery v0.0.0-20181026144827-8ee1a638bafa k8s.io/apimachinery/pkg/apis/meta/v1 k8s.io/apimachinery/pkg/runtime @@ -285,13 +290,13 @@ k8s.io/apimachinery/pkg/runtime/serializer k8s.io/apimachinery/pkg/watch k8s.io/apimachinery/pkg/labels k8s.io/apimachinery/pkg/api/errors -k8s.io/apimachinery/pkg/util/strategicpatch k8s.io/apimachinery/pkg/util/intstr k8s.io/apimachinery/pkg/util/runtime k8s.io/apimachinery/pkg/api/equality k8s.io/apimachinery/pkg/runtime/serializer/json k8s.io/apimachinery/pkg/api/meta k8s.io/apimachinery/pkg/apis/meta/v1/unstructured +k8s.io/apimachinery/pkg/util/strategicpatch k8s.io/apimachinery/pkg/util/wait k8s.io/apimachinery/pkg/api/validation k8s.io/apimachinery/pkg/conversion @@ -315,11 +320,11 @@ k8s.io/apimachinery/pkg/runtime/serializer/recognizer k8s.io/apimachinery/pkg/runtime/serializer/versioning k8s.io/apimachinery/pkg/util/cache k8s.io/apimachinery/pkg/util/diff -k8s.io/apimachinery/pkg/util/mergepatch -k8s.io/apimachinery/third_party/forked/golang/json k8s.io/apimachinery/pkg/util/framer k8s.io/apimachinery/pkg/util/yaml k8s.io/apimachinery/pkg/apis/meta/v1beta1 +k8s.io/apimachinery/pkg/util/mergepatch +k8s.io/apimachinery/third_party/forked/golang/json k8s.io/apimachinery/pkg/apis/meta/v1/validation k8s.io/apimachinery/third_party/forked/golang/reflect k8s.io/apimachinery/pkg/api/validation/path @@ -429,10 +434,10 @@ k8s.io/client-go/tools/cache k8s.io/client-go/listers/rbac/v1 k8s.io/client-go/util/workqueue k8s.io/client-go/informers +k8s.io/client-go/listers/core/v1 k8s.io/client-go/kubernetes/typed/core/v1 k8s.io/client-go/kubernetes k8s.io/client-go/listers/apps/v1 -k8s.io/client-go/listers/core/v1 k8s.io/client-go/util/cert k8s.io/client-go/tools/reference k8s.io/client-go/pkg/version @@ -449,7 +454,6 @@ k8s.io/client-go/tools/pager k8s.io/client-go/util/buffer k8s.io/client-go/util/retry k8s.io/client-go/kubernetes/fake -k8s.io/client-go/kubernetes/typed/core/v1/fake k8s.io/client-go/informers/admissionregistration k8s.io/client-go/informers/apps k8s.io/client-go/informers/autoscaling @@ -513,6 +517,7 @@ k8s.io/client-go/kubernetes/typed/batch/v1/fake k8s.io/client-go/kubernetes/typed/batch/v1beta1/fake k8s.io/client-go/kubernetes/typed/batch/v2alpha1/fake k8s.io/client-go/kubernetes/typed/certificates/v1beta1/fake +k8s.io/client-go/kubernetes/typed/core/v1/fake k8s.io/client-go/kubernetes/typed/events/v1beta1/fake k8s.io/client-go/kubernetes/typed/extensions/v1beta1/fake k8s.io/client-go/kubernetes/typed/networking/v1/fake