From aaeeaaf3158e63b7defbf890aec724ffc0b24f33 Mon Sep 17 00:00:00 2001 From: Stanislav Laznicka Date: Mon, 27 Jul 2020 14:34:44 +0200 Subject: [PATCH 1/5] add a controller to unmanage the OAuth API --- .../apiservices/unmanageoauthapicontroller.go | 53 +++++++++++ .../unmanageoauthapicontroller_test.go | 94 +++++++++++++++++++ pkg/operator2/starter.go | 15 ++- 3 files changed, 159 insertions(+), 3 deletions(-) create mode 100644 pkg/controller/apiservices/unmanageoauthapicontroller.go create mode 100644 pkg/controller/apiservices/unmanageoauthapicontroller_test.go diff --git a/pkg/controller/apiservices/unmanageoauthapicontroller.go b/pkg/controller/apiservices/unmanageoauthapicontroller.go new file mode 100644 index 000000000..c6a139e7b --- /dev/null +++ b/pkg/controller/apiservices/unmanageoauthapicontroller.go @@ -0,0 +1,53 @@ +package apiservices + +import ( + "context" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + operatorconfigclient "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1" + operatorclientinformers "github.com/openshift/client-go/operator/informers/externalversions" + operatorlistersv1 "github.com/openshift/client-go/operator/listers/operator/v1" + "github.com/openshift/library-go/pkg/controller/factory" + "github.com/openshift/library-go/pkg/operator/events" +) + +// NewUnmanageAPIServicesController sets ManagingOAuthAPIServer flag to false. +// This will make OAuth APIServer (introduced in 4.6) to step down and traffic +// will be routed to the OpenShift APIServer. It's a measure required for 4.6->4.5 +// downgrade. +// +// see https://github.com/openshift/enhancements/blob/master/enhancements/authentication/separate-oauth-resources.md +func NewUnmanageAPIServicesController( + name string, + authOperatorClient operatorconfigclient.AuthenticationsGetter, + authOperatorInformers operatorclientinformers.SharedInformerFactory, + eventRecorder events.Recorder, +) factory.Controller { + + authInformers := authOperatorInformers.Operator().V1().Authentications() + return factory.New(). + WithSync(syncUnmanageAPIServicesController(name, authOperatorClient, authInformers.Lister())). + WithInformers(authInformers.Informer()). + ToController(name, eventRecorder.WithComponentSuffix("unmanage-oauth-api-controller")) +} + +func syncUnmanageAPIServicesController(controllerName string, authOperatorClient operatorconfigclient.AuthenticationsGetter, authOperatorLister operatorlistersv1.AuthenticationLister) factory.SyncFunc { + return func(ctx context.Context, syncContext factory.SyncContext) error { + operator, err := authOperatorLister.Get("cluster") + if err != nil { + return err + } + + if operator.Status.ManagingOAuthAPIServer { + operatorCopy := operator.DeepCopy() + operatorCopy.Status.ManagingOAuthAPIServer = false + _, err = authOperatorClient.Authentications().UpdateStatus(ctx, operatorCopy, metav1.UpdateOptions{}) + if err == nil { + syncContext.Recorder().Eventf(controllerName, "turned OAuth API managing off") + } + } + + return err + } +} diff --git a/pkg/controller/apiservices/unmanageoauthapicontroller_test.go b/pkg/controller/apiservices/unmanageoauthapicontroller_test.go new file mode 100644 index 000000000..9ab6c7f8e --- /dev/null +++ b/pkg/controller/apiservices/unmanageoauthapicontroller_test.go @@ -0,0 +1,94 @@ +package apiservices + +import ( + "context" + "testing" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/tools/cache" + "k8s.io/client-go/util/workqueue" + + operatorv1 "github.com/openshift/api/operator/v1" + fakeoperator "github.com/openshift/client-go/operator/clientset/versioned/fake" + operatorv1listers "github.com/openshift/client-go/operator/listers/operator/v1" + "github.com/openshift/library-go/pkg/operator/events" +) + +func Test_syncUnmanageAPIServicesController(t *testing.T) { + tests := []struct { + name string + operatorStatus *operatorv1.AuthenticationStatus + changed bool + expectErr bool + }{ + { + name: "operator not found", + expectErr: true, + }, + { + name: "managed set to true", + operatorStatus: &operatorv1.AuthenticationStatus{ + ManagingOAuthAPIServer: true, + }, + changed: true, + }, + { + name: "managed set to false = no action", + operatorStatus: &operatorv1.AuthenticationStatus{ + ManagingOAuthAPIServer: false, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + authOps := []runtime.Object{} + indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}) + if tt.operatorStatus != nil { + operatorObj := &operatorv1.Authentication{ + ObjectMeta: metav1.ObjectMeta{ + Name: "cluster", + }, + Status: *tt.operatorStatus, + } + + if err := indexer.Add(operatorObj); err != nil { + t.Fatal(err) + } + authOps = append(authOps, operatorObj) + } + fakeOperatorClient := fakeoperator.NewSimpleClientset(authOps...) + operatorLister := operatorv1listers.NewAuthenticationLister(indexer) + + testRecorder := events.NewInMemoryRecorder("test") + if gotErr := syncUnmanageAPIServicesController("testUnmanagedController", fakeOperatorClient.OperatorV1(), operatorLister)(context.TODO(), testSyncContext{recorder: testRecorder}); tt.expectErr != (gotErr != nil) { + t.Errorf("syncUnmanageAPIServicesController() => expected error: %v, but got %v", tt.expectErr, gotErr) + } + + var updateObserved bool + for _, a := range fakeOperatorClient.Actions() { + if a.GetVerb() == "update" { + updateObserved = true + break + } + } + if !tt.changed { + if len(testRecorder.Events()) > 0 || updateObserved { + t.Errorf("expected the operator status to be the same, but that did not happen; update observed: %v; events: %v", updateObserved, testRecorder.Events()) + } + } else if len(testRecorder.Events()) == 0 || !updateObserved { + t.Errorf("expected change of the operator status:, but that did not happen; update observed: %v; events: %v", updateObserved, testRecorder.Events()) + } + }) + } +} + +type testSyncContext struct { + recorder events.Recorder +} + +func (c testSyncContext) Recorder() events.Recorder { return c.recorder } + +func (c testSyncContext) Queue() workqueue.RateLimitingInterface { return nil } + +func (c testSyncContext) QueueKey() string { return "testkey" } diff --git a/pkg/operator2/starter.go b/pkg/operator2/starter.go index 16ae229c4..3d04fac72 100644 --- a/pkg/operator2/starter.go +++ b/pkg/operator2/starter.go @@ -29,6 +29,7 @@ import ( "github.com/openshift/library-go/pkg/operator/unsupportedconfigoverridescontroller" "github.com/openshift/library-go/pkg/operator/v1helpers" + "github.com/openshift/cluster-authentication-operator/pkg/controller/apiservices" "github.com/openshift/cluster-authentication-operator/pkg/controller/ingressstate" "github.com/openshift/cluster-authentication-operator/pkg/operator2/assets" "github.com/openshift/cluster-authentication-operator/pkg/operator2/configobservation/configobservercontroller" @@ -74,7 +75,7 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle ) // short resync period as this drives the check frequency when checking the .well-known endpoint. 20 min is too slow for that. - authOperatorConfigInformers := authopinformer.NewSharedInformerFactoryWithOptions(authOperatorClient, time.Second*30, + authOperatorInformers := authopinformer.NewSharedInformerFactoryWithOptions(authOperatorClient, time.Second*30, authopinformer.WithTweakListOptions(singleNameListOptions("cluster")), ) @@ -95,7 +96,7 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle ) operatorClient := &OperatorClient{ - authOperatorConfigInformers, + authOperatorInformers, authOperatorClient.OperatorV1(), } @@ -226,6 +227,13 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle "openshift-authentication", controllerContext.EventRecorder) + unmanageOAuthAPIController := apiservices.NewUnmanageAPIServicesController( + "UnmanageOAuthAPIController", + authOperatorClient.OperatorV1(), + authOperatorInformers, + controllerContext.EventRecorder, + ) + // TODO remove this controller once we support Removed managementStateController := management.NewOperatorManagementStateController("authentication", operatorClient, controllerContext.EventRecorder) management.SetOperatorNotRemovable() @@ -234,7 +242,7 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle Start(stopCh <-chan struct{}) }{ kubeInformersNamespaced, - authOperatorConfigInformers, + authOperatorInformers, routeInformersNamespaced, configInformers, resourceSyncerInformers, @@ -251,6 +259,7 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle configOverridesController, logLevelController, managementStateController, + unmanageOAuthAPIController, routerCertsController, staleConditions, staticResourceController, From a9fc292fe875e705cfeae8be074b7ec3a39c72be Mon Sep 17 00:00:00 2001 From: Stanislav Laznicka Date: Mon, 27 Jul 2020 14:46:20 +0200 Subject: [PATCH 2/5] go mod tidy && go mod vendor --- .../versioned/fake/clientset_generated.go | 73 ++++++++++ .../operator/clientset/versioned/fake/doc.go | 4 + .../clientset/versioned/fake/register.go | 42 ++++++ .../versioned/typed/operator/v1/fake/doc.go | 4 + .../operator/v1/fake/fake_authentication.go | 117 ++++++++++++++++ .../typed/operator/v1/fake/fake_console.go | 117 ++++++++++++++++ .../v1/fake/fake_csisnapshotcontroller.go | 117 ++++++++++++++++ .../typed/operator/v1/fake/fake_dns.go | 117 ++++++++++++++++ .../typed/operator/v1/fake/fake_etcd.go | 117 ++++++++++++++++ .../v1/fake/fake_ingresscontroller.go | 126 ++++++++++++++++++ .../operator/v1/fake/fake_kubeapiserver.go | 117 ++++++++++++++++ .../v1/fake/fake_kubecontrollermanager.go | 117 ++++++++++++++++ .../operator/v1/fake/fake_kubescheduler.go | 117 ++++++++++++++++ .../fake/fake_kubestorageversionmigrator.go | 117 ++++++++++++++++ .../typed/operator/v1/fake/fake_network.go | 117 ++++++++++++++++ .../v1/fake/fake_openshiftapiserver.go | 117 ++++++++++++++++ .../fake/fake_openshiftcontrollermanager.go | 117 ++++++++++++++++ .../operator/v1/fake/fake_operator_client.go | 84 ++++++++++++ .../typed/operator/v1/fake/fake_serviceca.go | 117 ++++++++++++++++ .../v1/fake/fake_servicecatalogapiserver.go | 117 ++++++++++++++++ .../fake_servicecatalogcontrollermanager.go | 117 ++++++++++++++++ .../typed/operator/v1alpha1/fake/doc.go | 4 + .../fake/fake_imagecontentsourcepolicy.go | 106 +++++++++++++++ .../v1alpha1/fake/fake_operator_client.go | 24 ++++ vendor/modules.txt | 3 + 25 files changed, 2225 insertions(+) create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/clientset_generated.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/doc.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/register.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/doc.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_authentication.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_console.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_csisnapshotcontroller.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_dns.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_etcd.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_ingresscontroller.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubeapiserver.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubecontrollermanager.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubescheduler.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubestorageversionmigrator.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_network.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftapiserver.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftcontrollermanager.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_operator_client.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_serviceca.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogapiserver.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogcontrollermanager.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/doc.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_imagecontentsourcepolicy.go create mode 100644 vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/clientset_generated.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/clientset_generated.go new file mode 100644 index 000000000..d2fc3d301 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/clientset_generated.go @@ -0,0 +1,73 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + clientset "github.com/openshift/client-go/operator/clientset/versioned" + operatorv1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1" + fakeoperatorv1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake" + operatorv1alpha1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1" + fakeoperatorv1alpha1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/discovery" + fakediscovery "k8s.io/client-go/discovery/fake" + "k8s.io/client-go/testing" +) + +// NewSimpleClientset returns a clientset that will respond with the provided objects. +// It's backed by a very simple object tracker that processes creates, updates and deletions as-is, +// without applying any validations and/or defaults. It shouldn't be considered a replacement +// for a real clientset and is mostly useful in simple unit tests. +func NewSimpleClientset(objects ...runtime.Object) *Clientset { + o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder()) + for _, obj := range objects { + if err := o.Add(obj); err != nil { + panic(err) + } + } + + cs := &Clientset{tracker: o} + cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake} + cs.AddReactor("*", "*", testing.ObjectReaction(o)) + cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) { + gvr := action.GetResource() + ns := action.GetNamespace() + watch, err := o.Watch(gvr, ns) + if err != nil { + return false, nil, err + } + return true, watch, nil + }) + + return cs +} + +// Clientset implements clientset.Interface. Meant to be embedded into a +// struct to get a default implementation. This makes faking out just the method +// you want to test easier. +type Clientset struct { + testing.Fake + discovery *fakediscovery.FakeDiscovery + tracker testing.ObjectTracker +} + +func (c *Clientset) Discovery() discovery.DiscoveryInterface { + return c.discovery +} + +func (c *Clientset) Tracker() testing.ObjectTracker { + return c.tracker +} + +var _ clientset.Interface = &Clientset{} + +// OperatorV1 retrieves the OperatorV1Client +func (c *Clientset) OperatorV1() operatorv1.OperatorV1Interface { + return &fakeoperatorv1.FakeOperatorV1{Fake: &c.Fake} +} + +// OperatorV1alpha1 retrieves the OperatorV1alpha1Client +func (c *Clientset) OperatorV1alpha1() operatorv1alpha1.OperatorV1alpha1Interface { + return &fakeoperatorv1alpha1.FakeOperatorV1alpha1{Fake: &c.Fake} +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/doc.go new file mode 100644 index 000000000..3630ed1cd --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// This package has the automatically generated fake clientset. +package fake diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/register.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/register.go new file mode 100644 index 000000000..20d540bc0 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/fake/register.go @@ -0,0 +1,42 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + operatorv1 "github.com/openshift/api/operator/v1" + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + schema "k8s.io/apimachinery/pkg/runtime/schema" + serializer "k8s.io/apimachinery/pkg/runtime/serializer" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" +) + +var scheme = runtime.NewScheme() +var codecs = serializer.NewCodecFactory(scheme) +var parameterCodec = runtime.NewParameterCodec(scheme) +var localSchemeBuilder = runtime.SchemeBuilder{ + operatorv1.AddToScheme, + operatorv1alpha1.AddToScheme, +} + +// AddToScheme adds all types of this clientset into the given scheme. This allows composition +// of clientsets, like in: +// +// import ( +// "k8s.io/client-go/kubernetes" +// clientsetscheme "k8s.io/client-go/kubernetes/scheme" +// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme" +// ) +// +// kclientset, _ := kubernetes.NewForConfig(c) +// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme) +// +// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types +// correctly. +var AddToScheme = localSchemeBuilder.AddToScheme + +func init() { + v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"}) + utilruntime.Must(AddToScheme(scheme)) +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/doc.go new file mode 100644 index 000000000..2b5ba4c8e --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// Package fake has the automatically generated clients. +package fake diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_authentication.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_authentication.go new file mode 100644 index 000000000..e2f0a6c31 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_authentication.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeAuthentications implements AuthenticationInterface +type FakeAuthentications struct { + Fake *FakeOperatorV1 +} + +var authenticationsResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "authentications"} + +var authenticationsKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "Authentication"} + +// Get takes name of the authentication, and returns the corresponding authentication object, and an error if there is any. +func (c *FakeAuthentications) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.Authentication, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(authenticationsResource, name), &operatorv1.Authentication{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Authentication), err +} + +// List takes label and field selectors, and returns the list of Authentications that match those selectors. +func (c *FakeAuthentications) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.AuthenticationList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(authenticationsResource, authenticationsKind, opts), &operatorv1.AuthenticationList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.AuthenticationList{ListMeta: obj.(*operatorv1.AuthenticationList).ListMeta} + for _, item := range obj.(*operatorv1.AuthenticationList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested authentications. +func (c *FakeAuthentications) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(authenticationsResource, opts)) +} + +// Create takes the representation of a authentication and creates it. Returns the server's representation of the authentication, and an error, if there is any. +func (c *FakeAuthentications) Create(ctx context.Context, authentication *operatorv1.Authentication, opts v1.CreateOptions) (result *operatorv1.Authentication, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(authenticationsResource, authentication), &operatorv1.Authentication{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Authentication), err +} + +// Update takes the representation of a authentication and updates it. Returns the server's representation of the authentication, and an error, if there is any. +func (c *FakeAuthentications) Update(ctx context.Context, authentication *operatorv1.Authentication, opts v1.UpdateOptions) (result *operatorv1.Authentication, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(authenticationsResource, authentication), &operatorv1.Authentication{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Authentication), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeAuthentications) UpdateStatus(ctx context.Context, authentication *operatorv1.Authentication, opts v1.UpdateOptions) (*operatorv1.Authentication, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(authenticationsResource, "status", authentication), &operatorv1.Authentication{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Authentication), err +} + +// Delete takes name of the authentication and deletes it. Returns an error if one occurs. +func (c *FakeAuthentications) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(authenticationsResource, name), &operatorv1.Authentication{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeAuthentications) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(authenticationsResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.AuthenticationList{}) + return err +} + +// Patch applies the patch and returns the patched authentication. +func (c *FakeAuthentications) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.Authentication, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(authenticationsResource, name, pt, data, subresources...), &operatorv1.Authentication{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Authentication), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_console.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_console.go new file mode 100644 index 000000000..26461daee --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_console.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeConsoles implements ConsoleInterface +type FakeConsoles struct { + Fake *FakeOperatorV1 +} + +var consolesResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "consoles"} + +var consolesKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "Console"} + +// Get takes name of the console, and returns the corresponding console object, and an error if there is any. +func (c *FakeConsoles) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.Console, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(consolesResource, name), &operatorv1.Console{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Console), err +} + +// List takes label and field selectors, and returns the list of Consoles that match those selectors. +func (c *FakeConsoles) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.ConsoleList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(consolesResource, consolesKind, opts), &operatorv1.ConsoleList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.ConsoleList{ListMeta: obj.(*operatorv1.ConsoleList).ListMeta} + for _, item := range obj.(*operatorv1.ConsoleList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested consoles. +func (c *FakeConsoles) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(consolesResource, opts)) +} + +// Create takes the representation of a console and creates it. Returns the server's representation of the console, and an error, if there is any. +func (c *FakeConsoles) Create(ctx context.Context, console *operatorv1.Console, opts v1.CreateOptions) (result *operatorv1.Console, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(consolesResource, console), &operatorv1.Console{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Console), err +} + +// Update takes the representation of a console and updates it. Returns the server's representation of the console, and an error, if there is any. +func (c *FakeConsoles) Update(ctx context.Context, console *operatorv1.Console, opts v1.UpdateOptions) (result *operatorv1.Console, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(consolesResource, console), &operatorv1.Console{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Console), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeConsoles) UpdateStatus(ctx context.Context, console *operatorv1.Console, opts v1.UpdateOptions) (*operatorv1.Console, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(consolesResource, "status", console), &operatorv1.Console{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Console), err +} + +// Delete takes name of the console and deletes it. Returns an error if one occurs. +func (c *FakeConsoles) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(consolesResource, name), &operatorv1.Console{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeConsoles) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(consolesResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.ConsoleList{}) + return err +} + +// Patch applies the patch and returns the patched console. +func (c *FakeConsoles) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.Console, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(consolesResource, name, pt, data, subresources...), &operatorv1.Console{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Console), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_csisnapshotcontroller.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_csisnapshotcontroller.go new file mode 100644 index 000000000..21fedf57b --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_csisnapshotcontroller.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeCSISnapshotControllers implements CSISnapshotControllerInterface +type FakeCSISnapshotControllers struct { + Fake *FakeOperatorV1 +} + +var csisnapshotcontrollersResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "csisnapshotcontrollers"} + +var csisnapshotcontrollersKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "CSISnapshotController"} + +// Get takes name of the cSISnapshotController, and returns the corresponding cSISnapshotController object, and an error if there is any. +func (c *FakeCSISnapshotControllers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.CSISnapshotController, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(csisnapshotcontrollersResource, name), &operatorv1.CSISnapshotController{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.CSISnapshotController), err +} + +// List takes label and field selectors, and returns the list of CSISnapshotControllers that match those selectors. +func (c *FakeCSISnapshotControllers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.CSISnapshotControllerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(csisnapshotcontrollersResource, csisnapshotcontrollersKind, opts), &operatorv1.CSISnapshotControllerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.CSISnapshotControllerList{ListMeta: obj.(*operatorv1.CSISnapshotControllerList).ListMeta} + for _, item := range obj.(*operatorv1.CSISnapshotControllerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested cSISnapshotControllers. +func (c *FakeCSISnapshotControllers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(csisnapshotcontrollersResource, opts)) +} + +// Create takes the representation of a cSISnapshotController and creates it. Returns the server's representation of the cSISnapshotController, and an error, if there is any. +func (c *FakeCSISnapshotControllers) Create(ctx context.Context, cSISnapshotController *operatorv1.CSISnapshotController, opts v1.CreateOptions) (result *operatorv1.CSISnapshotController, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(csisnapshotcontrollersResource, cSISnapshotController), &operatorv1.CSISnapshotController{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.CSISnapshotController), err +} + +// Update takes the representation of a cSISnapshotController and updates it. Returns the server's representation of the cSISnapshotController, and an error, if there is any. +func (c *FakeCSISnapshotControllers) Update(ctx context.Context, cSISnapshotController *operatorv1.CSISnapshotController, opts v1.UpdateOptions) (result *operatorv1.CSISnapshotController, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(csisnapshotcontrollersResource, cSISnapshotController), &operatorv1.CSISnapshotController{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.CSISnapshotController), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeCSISnapshotControllers) UpdateStatus(ctx context.Context, cSISnapshotController *operatorv1.CSISnapshotController, opts v1.UpdateOptions) (*operatorv1.CSISnapshotController, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(csisnapshotcontrollersResource, "status", cSISnapshotController), &operatorv1.CSISnapshotController{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.CSISnapshotController), err +} + +// Delete takes name of the cSISnapshotController and deletes it. Returns an error if one occurs. +func (c *FakeCSISnapshotControllers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(csisnapshotcontrollersResource, name), &operatorv1.CSISnapshotController{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeCSISnapshotControllers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(csisnapshotcontrollersResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.CSISnapshotControllerList{}) + return err +} + +// Patch applies the patch and returns the patched cSISnapshotController. +func (c *FakeCSISnapshotControllers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.CSISnapshotController, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(csisnapshotcontrollersResource, name, pt, data, subresources...), &operatorv1.CSISnapshotController{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.CSISnapshotController), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_dns.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_dns.go new file mode 100644 index 000000000..bacf117cf --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_dns.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeDNSes implements DNSInterface +type FakeDNSes struct { + Fake *FakeOperatorV1 +} + +var dnsesResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "dnses"} + +var dnsesKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "DNS"} + +// Get takes name of the dNS, and returns the corresponding dNS object, and an error if there is any. +func (c *FakeDNSes) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.DNS, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(dnsesResource, name), &operatorv1.DNS{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.DNS), err +} + +// List takes label and field selectors, and returns the list of DNSes that match those selectors. +func (c *FakeDNSes) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.DNSList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(dnsesResource, dnsesKind, opts), &operatorv1.DNSList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.DNSList{ListMeta: obj.(*operatorv1.DNSList).ListMeta} + for _, item := range obj.(*operatorv1.DNSList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested dNSes. +func (c *FakeDNSes) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(dnsesResource, opts)) +} + +// Create takes the representation of a dNS and creates it. Returns the server's representation of the dNS, and an error, if there is any. +func (c *FakeDNSes) Create(ctx context.Context, dNS *operatorv1.DNS, opts v1.CreateOptions) (result *operatorv1.DNS, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(dnsesResource, dNS), &operatorv1.DNS{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.DNS), err +} + +// Update takes the representation of a dNS and updates it. Returns the server's representation of the dNS, and an error, if there is any. +func (c *FakeDNSes) Update(ctx context.Context, dNS *operatorv1.DNS, opts v1.UpdateOptions) (result *operatorv1.DNS, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(dnsesResource, dNS), &operatorv1.DNS{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.DNS), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeDNSes) UpdateStatus(ctx context.Context, dNS *operatorv1.DNS, opts v1.UpdateOptions) (*operatorv1.DNS, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(dnsesResource, "status", dNS), &operatorv1.DNS{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.DNS), err +} + +// Delete takes name of the dNS and deletes it. Returns an error if one occurs. +func (c *FakeDNSes) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(dnsesResource, name), &operatorv1.DNS{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeDNSes) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(dnsesResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.DNSList{}) + return err +} + +// Patch applies the patch and returns the patched dNS. +func (c *FakeDNSes) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.DNS, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(dnsesResource, name, pt, data, subresources...), &operatorv1.DNS{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.DNS), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_etcd.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_etcd.go new file mode 100644 index 000000000..30b446df3 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_etcd.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeEtcds implements EtcdInterface +type FakeEtcds struct { + Fake *FakeOperatorV1 +} + +var etcdsResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "etcds"} + +var etcdsKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "Etcd"} + +// Get takes name of the etcd, and returns the corresponding etcd object, and an error if there is any. +func (c *FakeEtcds) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.Etcd, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(etcdsResource, name), &operatorv1.Etcd{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Etcd), err +} + +// List takes label and field selectors, and returns the list of Etcds that match those selectors. +func (c *FakeEtcds) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.EtcdList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(etcdsResource, etcdsKind, opts), &operatorv1.EtcdList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.EtcdList{ListMeta: obj.(*operatorv1.EtcdList).ListMeta} + for _, item := range obj.(*operatorv1.EtcdList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested etcds. +func (c *FakeEtcds) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(etcdsResource, opts)) +} + +// Create takes the representation of a etcd and creates it. Returns the server's representation of the etcd, and an error, if there is any. +func (c *FakeEtcds) Create(ctx context.Context, etcd *operatorv1.Etcd, opts v1.CreateOptions) (result *operatorv1.Etcd, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(etcdsResource, etcd), &operatorv1.Etcd{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Etcd), err +} + +// Update takes the representation of a etcd and updates it. Returns the server's representation of the etcd, and an error, if there is any. +func (c *FakeEtcds) Update(ctx context.Context, etcd *operatorv1.Etcd, opts v1.UpdateOptions) (result *operatorv1.Etcd, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(etcdsResource, etcd), &operatorv1.Etcd{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Etcd), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeEtcds) UpdateStatus(ctx context.Context, etcd *operatorv1.Etcd, opts v1.UpdateOptions) (*operatorv1.Etcd, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(etcdsResource, "status", etcd), &operatorv1.Etcd{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Etcd), err +} + +// Delete takes name of the etcd and deletes it. Returns an error if one occurs. +func (c *FakeEtcds) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(etcdsResource, name), &operatorv1.Etcd{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeEtcds) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(etcdsResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.EtcdList{}) + return err +} + +// Patch applies the patch and returns the patched etcd. +func (c *FakeEtcds) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.Etcd, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(etcdsResource, name, pt, data, subresources...), &operatorv1.Etcd{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Etcd), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_ingresscontroller.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_ingresscontroller.go new file mode 100644 index 000000000..d1ec59b4e --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_ingresscontroller.go @@ -0,0 +1,126 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeIngressControllers implements IngressControllerInterface +type FakeIngressControllers struct { + Fake *FakeOperatorV1 + ns string +} + +var ingresscontrollersResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "ingresscontrollers"} + +var ingresscontrollersKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "IngressController"} + +// Get takes name of the ingressController, and returns the corresponding ingressController object, and an error if there is any. +func (c *FakeIngressControllers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.IngressController, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(ingresscontrollersResource, c.ns, name), &operatorv1.IngressController{}) + + if obj == nil { + return nil, err + } + return obj.(*operatorv1.IngressController), err +} + +// List takes label and field selectors, and returns the list of IngressControllers that match those selectors. +func (c *FakeIngressControllers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.IngressControllerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(ingresscontrollersResource, ingresscontrollersKind, c.ns, opts), &operatorv1.IngressControllerList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.IngressControllerList{ListMeta: obj.(*operatorv1.IngressControllerList).ListMeta} + for _, item := range obj.(*operatorv1.IngressControllerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested ingressControllers. +func (c *FakeIngressControllers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(ingresscontrollersResource, c.ns, opts)) + +} + +// Create takes the representation of a ingressController and creates it. Returns the server's representation of the ingressController, and an error, if there is any. +func (c *FakeIngressControllers) Create(ctx context.Context, ingressController *operatorv1.IngressController, opts v1.CreateOptions) (result *operatorv1.IngressController, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(ingresscontrollersResource, c.ns, ingressController), &operatorv1.IngressController{}) + + if obj == nil { + return nil, err + } + return obj.(*operatorv1.IngressController), err +} + +// Update takes the representation of a ingressController and updates it. Returns the server's representation of the ingressController, and an error, if there is any. +func (c *FakeIngressControllers) Update(ctx context.Context, ingressController *operatorv1.IngressController, opts v1.UpdateOptions) (result *operatorv1.IngressController, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(ingresscontrollersResource, c.ns, ingressController), &operatorv1.IngressController{}) + + if obj == nil { + return nil, err + } + return obj.(*operatorv1.IngressController), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeIngressControllers) UpdateStatus(ctx context.Context, ingressController *operatorv1.IngressController, opts v1.UpdateOptions) (*operatorv1.IngressController, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(ingresscontrollersResource, "status", c.ns, ingressController), &operatorv1.IngressController{}) + + if obj == nil { + return nil, err + } + return obj.(*operatorv1.IngressController), err +} + +// Delete takes name of the ingressController and deletes it. Returns an error if one occurs. +func (c *FakeIngressControllers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteAction(ingresscontrollersResource, c.ns, name), &operatorv1.IngressController{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeIngressControllers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(ingresscontrollersResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.IngressControllerList{}) + return err +} + +// Patch applies the patch and returns the patched ingressController. +func (c *FakeIngressControllers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.IngressController, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(ingresscontrollersResource, c.ns, name, pt, data, subresources...), &operatorv1.IngressController{}) + + if obj == nil { + return nil, err + } + return obj.(*operatorv1.IngressController), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubeapiserver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubeapiserver.go new file mode 100644 index 000000000..dc7becf1d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubeapiserver.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeKubeAPIServers implements KubeAPIServerInterface +type FakeKubeAPIServers struct { + Fake *FakeOperatorV1 +} + +var kubeapiserversResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "kubeapiservers"} + +var kubeapiserversKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "KubeAPIServer"} + +// Get takes name of the kubeAPIServer, and returns the corresponding kubeAPIServer object, and an error if there is any. +func (c *FakeKubeAPIServers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.KubeAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(kubeapiserversResource, name), &operatorv1.KubeAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeAPIServer), err +} + +// List takes label and field selectors, and returns the list of KubeAPIServers that match those selectors. +func (c *FakeKubeAPIServers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.KubeAPIServerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(kubeapiserversResource, kubeapiserversKind, opts), &operatorv1.KubeAPIServerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.KubeAPIServerList{ListMeta: obj.(*operatorv1.KubeAPIServerList).ListMeta} + for _, item := range obj.(*operatorv1.KubeAPIServerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested kubeAPIServers. +func (c *FakeKubeAPIServers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(kubeapiserversResource, opts)) +} + +// Create takes the representation of a kubeAPIServer and creates it. Returns the server's representation of the kubeAPIServer, and an error, if there is any. +func (c *FakeKubeAPIServers) Create(ctx context.Context, kubeAPIServer *operatorv1.KubeAPIServer, opts v1.CreateOptions) (result *operatorv1.KubeAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(kubeapiserversResource, kubeAPIServer), &operatorv1.KubeAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeAPIServer), err +} + +// Update takes the representation of a kubeAPIServer and updates it. Returns the server's representation of the kubeAPIServer, and an error, if there is any. +func (c *FakeKubeAPIServers) Update(ctx context.Context, kubeAPIServer *operatorv1.KubeAPIServer, opts v1.UpdateOptions) (result *operatorv1.KubeAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(kubeapiserversResource, kubeAPIServer), &operatorv1.KubeAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeAPIServer), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeKubeAPIServers) UpdateStatus(ctx context.Context, kubeAPIServer *operatorv1.KubeAPIServer, opts v1.UpdateOptions) (*operatorv1.KubeAPIServer, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(kubeapiserversResource, "status", kubeAPIServer), &operatorv1.KubeAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeAPIServer), err +} + +// Delete takes name of the kubeAPIServer and deletes it. Returns an error if one occurs. +func (c *FakeKubeAPIServers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(kubeapiserversResource, name), &operatorv1.KubeAPIServer{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeKubeAPIServers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(kubeapiserversResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.KubeAPIServerList{}) + return err +} + +// Patch applies the patch and returns the patched kubeAPIServer. +func (c *FakeKubeAPIServers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.KubeAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(kubeapiserversResource, name, pt, data, subresources...), &operatorv1.KubeAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeAPIServer), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubecontrollermanager.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubecontrollermanager.go new file mode 100644 index 000000000..e5bc5b060 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubecontrollermanager.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeKubeControllerManagers implements KubeControllerManagerInterface +type FakeKubeControllerManagers struct { + Fake *FakeOperatorV1 +} + +var kubecontrollermanagersResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "kubecontrollermanagers"} + +var kubecontrollermanagersKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "KubeControllerManager"} + +// Get takes name of the kubeControllerManager, and returns the corresponding kubeControllerManager object, and an error if there is any. +func (c *FakeKubeControllerManagers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.KubeControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(kubecontrollermanagersResource, name), &operatorv1.KubeControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeControllerManager), err +} + +// List takes label and field selectors, and returns the list of KubeControllerManagers that match those selectors. +func (c *FakeKubeControllerManagers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.KubeControllerManagerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(kubecontrollermanagersResource, kubecontrollermanagersKind, opts), &operatorv1.KubeControllerManagerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.KubeControllerManagerList{ListMeta: obj.(*operatorv1.KubeControllerManagerList).ListMeta} + for _, item := range obj.(*operatorv1.KubeControllerManagerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested kubeControllerManagers. +func (c *FakeKubeControllerManagers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(kubecontrollermanagersResource, opts)) +} + +// Create takes the representation of a kubeControllerManager and creates it. Returns the server's representation of the kubeControllerManager, and an error, if there is any. +func (c *FakeKubeControllerManagers) Create(ctx context.Context, kubeControllerManager *operatorv1.KubeControllerManager, opts v1.CreateOptions) (result *operatorv1.KubeControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(kubecontrollermanagersResource, kubeControllerManager), &operatorv1.KubeControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeControllerManager), err +} + +// Update takes the representation of a kubeControllerManager and updates it. Returns the server's representation of the kubeControllerManager, and an error, if there is any. +func (c *FakeKubeControllerManagers) Update(ctx context.Context, kubeControllerManager *operatorv1.KubeControllerManager, opts v1.UpdateOptions) (result *operatorv1.KubeControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(kubecontrollermanagersResource, kubeControllerManager), &operatorv1.KubeControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeControllerManager), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeKubeControllerManagers) UpdateStatus(ctx context.Context, kubeControllerManager *operatorv1.KubeControllerManager, opts v1.UpdateOptions) (*operatorv1.KubeControllerManager, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(kubecontrollermanagersResource, "status", kubeControllerManager), &operatorv1.KubeControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeControllerManager), err +} + +// Delete takes name of the kubeControllerManager and deletes it. Returns an error if one occurs. +func (c *FakeKubeControllerManagers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(kubecontrollermanagersResource, name), &operatorv1.KubeControllerManager{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeKubeControllerManagers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(kubecontrollermanagersResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.KubeControllerManagerList{}) + return err +} + +// Patch applies the patch and returns the patched kubeControllerManager. +func (c *FakeKubeControllerManagers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.KubeControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(kubecontrollermanagersResource, name, pt, data, subresources...), &operatorv1.KubeControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeControllerManager), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubescheduler.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubescheduler.go new file mode 100644 index 000000000..d1c2bdd74 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubescheduler.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeKubeSchedulers implements KubeSchedulerInterface +type FakeKubeSchedulers struct { + Fake *FakeOperatorV1 +} + +var kubeschedulersResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "kubeschedulers"} + +var kubeschedulersKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "KubeScheduler"} + +// Get takes name of the kubeScheduler, and returns the corresponding kubeScheduler object, and an error if there is any. +func (c *FakeKubeSchedulers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.KubeScheduler, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(kubeschedulersResource, name), &operatorv1.KubeScheduler{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeScheduler), err +} + +// List takes label and field selectors, and returns the list of KubeSchedulers that match those selectors. +func (c *FakeKubeSchedulers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.KubeSchedulerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(kubeschedulersResource, kubeschedulersKind, opts), &operatorv1.KubeSchedulerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.KubeSchedulerList{ListMeta: obj.(*operatorv1.KubeSchedulerList).ListMeta} + for _, item := range obj.(*operatorv1.KubeSchedulerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested kubeSchedulers. +func (c *FakeKubeSchedulers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(kubeschedulersResource, opts)) +} + +// Create takes the representation of a kubeScheduler and creates it. Returns the server's representation of the kubeScheduler, and an error, if there is any. +func (c *FakeKubeSchedulers) Create(ctx context.Context, kubeScheduler *operatorv1.KubeScheduler, opts v1.CreateOptions) (result *operatorv1.KubeScheduler, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(kubeschedulersResource, kubeScheduler), &operatorv1.KubeScheduler{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeScheduler), err +} + +// Update takes the representation of a kubeScheduler and updates it. Returns the server's representation of the kubeScheduler, and an error, if there is any. +func (c *FakeKubeSchedulers) Update(ctx context.Context, kubeScheduler *operatorv1.KubeScheduler, opts v1.UpdateOptions) (result *operatorv1.KubeScheduler, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(kubeschedulersResource, kubeScheduler), &operatorv1.KubeScheduler{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeScheduler), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeKubeSchedulers) UpdateStatus(ctx context.Context, kubeScheduler *operatorv1.KubeScheduler, opts v1.UpdateOptions) (*operatorv1.KubeScheduler, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(kubeschedulersResource, "status", kubeScheduler), &operatorv1.KubeScheduler{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeScheduler), err +} + +// Delete takes name of the kubeScheduler and deletes it. Returns an error if one occurs. +func (c *FakeKubeSchedulers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(kubeschedulersResource, name), &operatorv1.KubeScheduler{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeKubeSchedulers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(kubeschedulersResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.KubeSchedulerList{}) + return err +} + +// Patch applies the patch and returns the patched kubeScheduler. +func (c *FakeKubeSchedulers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.KubeScheduler, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(kubeschedulersResource, name, pt, data, subresources...), &operatorv1.KubeScheduler{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeScheduler), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubestorageversionmigrator.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubestorageversionmigrator.go new file mode 100644 index 000000000..6fa99604d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_kubestorageversionmigrator.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeKubeStorageVersionMigrators implements KubeStorageVersionMigratorInterface +type FakeKubeStorageVersionMigrators struct { + Fake *FakeOperatorV1 +} + +var kubestorageversionmigratorsResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "kubestorageversionmigrators"} + +var kubestorageversionmigratorsKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "KubeStorageVersionMigrator"} + +// Get takes name of the kubeStorageVersionMigrator, and returns the corresponding kubeStorageVersionMigrator object, and an error if there is any. +func (c *FakeKubeStorageVersionMigrators) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.KubeStorageVersionMigrator, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(kubestorageversionmigratorsResource, name), &operatorv1.KubeStorageVersionMigrator{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeStorageVersionMigrator), err +} + +// List takes label and field selectors, and returns the list of KubeStorageVersionMigrators that match those selectors. +func (c *FakeKubeStorageVersionMigrators) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.KubeStorageVersionMigratorList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(kubestorageversionmigratorsResource, kubestorageversionmigratorsKind, opts), &operatorv1.KubeStorageVersionMigratorList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.KubeStorageVersionMigratorList{ListMeta: obj.(*operatorv1.KubeStorageVersionMigratorList).ListMeta} + for _, item := range obj.(*operatorv1.KubeStorageVersionMigratorList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested kubeStorageVersionMigrators. +func (c *FakeKubeStorageVersionMigrators) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(kubestorageversionmigratorsResource, opts)) +} + +// Create takes the representation of a kubeStorageVersionMigrator and creates it. Returns the server's representation of the kubeStorageVersionMigrator, and an error, if there is any. +func (c *FakeKubeStorageVersionMigrators) Create(ctx context.Context, kubeStorageVersionMigrator *operatorv1.KubeStorageVersionMigrator, opts v1.CreateOptions) (result *operatorv1.KubeStorageVersionMigrator, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(kubestorageversionmigratorsResource, kubeStorageVersionMigrator), &operatorv1.KubeStorageVersionMigrator{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeStorageVersionMigrator), err +} + +// Update takes the representation of a kubeStorageVersionMigrator and updates it. Returns the server's representation of the kubeStorageVersionMigrator, and an error, if there is any. +func (c *FakeKubeStorageVersionMigrators) Update(ctx context.Context, kubeStorageVersionMigrator *operatorv1.KubeStorageVersionMigrator, opts v1.UpdateOptions) (result *operatorv1.KubeStorageVersionMigrator, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(kubestorageversionmigratorsResource, kubeStorageVersionMigrator), &operatorv1.KubeStorageVersionMigrator{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeStorageVersionMigrator), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeKubeStorageVersionMigrators) UpdateStatus(ctx context.Context, kubeStorageVersionMigrator *operatorv1.KubeStorageVersionMigrator, opts v1.UpdateOptions) (*operatorv1.KubeStorageVersionMigrator, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(kubestorageversionmigratorsResource, "status", kubeStorageVersionMigrator), &operatorv1.KubeStorageVersionMigrator{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeStorageVersionMigrator), err +} + +// Delete takes name of the kubeStorageVersionMigrator and deletes it. Returns an error if one occurs. +func (c *FakeKubeStorageVersionMigrators) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(kubestorageversionmigratorsResource, name), &operatorv1.KubeStorageVersionMigrator{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeKubeStorageVersionMigrators) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(kubestorageversionmigratorsResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.KubeStorageVersionMigratorList{}) + return err +} + +// Patch applies the patch and returns the patched kubeStorageVersionMigrator. +func (c *FakeKubeStorageVersionMigrators) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.KubeStorageVersionMigrator, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(kubestorageversionmigratorsResource, name, pt, data, subresources...), &operatorv1.KubeStorageVersionMigrator{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.KubeStorageVersionMigrator), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_network.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_network.go new file mode 100644 index 000000000..6e54f5b8d --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_network.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeNetworks implements NetworkInterface +type FakeNetworks struct { + Fake *FakeOperatorV1 +} + +var networksResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "networks"} + +var networksKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "Network"} + +// Get takes name of the network, and returns the corresponding network object, and an error if there is any. +func (c *FakeNetworks) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.Network, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(networksResource, name), &operatorv1.Network{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Network), err +} + +// List takes label and field selectors, and returns the list of Networks that match those selectors. +func (c *FakeNetworks) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.NetworkList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(networksResource, networksKind, opts), &operatorv1.NetworkList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.NetworkList{ListMeta: obj.(*operatorv1.NetworkList).ListMeta} + for _, item := range obj.(*operatorv1.NetworkList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested networks. +func (c *FakeNetworks) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(networksResource, opts)) +} + +// Create takes the representation of a network and creates it. Returns the server's representation of the network, and an error, if there is any. +func (c *FakeNetworks) Create(ctx context.Context, network *operatorv1.Network, opts v1.CreateOptions) (result *operatorv1.Network, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(networksResource, network), &operatorv1.Network{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Network), err +} + +// Update takes the representation of a network and updates it. Returns the server's representation of the network, and an error, if there is any. +func (c *FakeNetworks) Update(ctx context.Context, network *operatorv1.Network, opts v1.UpdateOptions) (result *operatorv1.Network, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(networksResource, network), &operatorv1.Network{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Network), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeNetworks) UpdateStatus(ctx context.Context, network *operatorv1.Network, opts v1.UpdateOptions) (*operatorv1.Network, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(networksResource, "status", network), &operatorv1.Network{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Network), err +} + +// Delete takes name of the network and deletes it. Returns an error if one occurs. +func (c *FakeNetworks) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(networksResource, name), &operatorv1.Network{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeNetworks) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(networksResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.NetworkList{}) + return err +} + +// Patch applies the patch and returns the patched network. +func (c *FakeNetworks) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.Network, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(networksResource, name, pt, data, subresources...), &operatorv1.Network{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.Network), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftapiserver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftapiserver.go new file mode 100644 index 000000000..92a620953 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftapiserver.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeOpenShiftAPIServers implements OpenShiftAPIServerInterface +type FakeOpenShiftAPIServers struct { + Fake *FakeOperatorV1 +} + +var openshiftapiserversResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "openshiftapiservers"} + +var openshiftapiserversKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "OpenShiftAPIServer"} + +// Get takes name of the openShiftAPIServer, and returns the corresponding openShiftAPIServer object, and an error if there is any. +func (c *FakeOpenShiftAPIServers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.OpenShiftAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(openshiftapiserversResource, name), &operatorv1.OpenShiftAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftAPIServer), err +} + +// List takes label and field selectors, and returns the list of OpenShiftAPIServers that match those selectors. +func (c *FakeOpenShiftAPIServers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.OpenShiftAPIServerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(openshiftapiserversResource, openshiftapiserversKind, opts), &operatorv1.OpenShiftAPIServerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.OpenShiftAPIServerList{ListMeta: obj.(*operatorv1.OpenShiftAPIServerList).ListMeta} + for _, item := range obj.(*operatorv1.OpenShiftAPIServerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested openShiftAPIServers. +func (c *FakeOpenShiftAPIServers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(openshiftapiserversResource, opts)) +} + +// Create takes the representation of a openShiftAPIServer and creates it. Returns the server's representation of the openShiftAPIServer, and an error, if there is any. +func (c *FakeOpenShiftAPIServers) Create(ctx context.Context, openShiftAPIServer *operatorv1.OpenShiftAPIServer, opts v1.CreateOptions) (result *operatorv1.OpenShiftAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(openshiftapiserversResource, openShiftAPIServer), &operatorv1.OpenShiftAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftAPIServer), err +} + +// Update takes the representation of a openShiftAPIServer and updates it. Returns the server's representation of the openShiftAPIServer, and an error, if there is any. +func (c *FakeOpenShiftAPIServers) Update(ctx context.Context, openShiftAPIServer *operatorv1.OpenShiftAPIServer, opts v1.UpdateOptions) (result *operatorv1.OpenShiftAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(openshiftapiserversResource, openShiftAPIServer), &operatorv1.OpenShiftAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftAPIServer), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeOpenShiftAPIServers) UpdateStatus(ctx context.Context, openShiftAPIServer *operatorv1.OpenShiftAPIServer, opts v1.UpdateOptions) (*operatorv1.OpenShiftAPIServer, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(openshiftapiserversResource, "status", openShiftAPIServer), &operatorv1.OpenShiftAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftAPIServer), err +} + +// Delete takes name of the openShiftAPIServer and deletes it. Returns an error if one occurs. +func (c *FakeOpenShiftAPIServers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(openshiftapiserversResource, name), &operatorv1.OpenShiftAPIServer{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeOpenShiftAPIServers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(openshiftapiserversResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.OpenShiftAPIServerList{}) + return err +} + +// Patch applies the patch and returns the patched openShiftAPIServer. +func (c *FakeOpenShiftAPIServers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.OpenShiftAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(openshiftapiserversResource, name, pt, data, subresources...), &operatorv1.OpenShiftAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftAPIServer), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftcontrollermanager.go new file mode 100644 index 000000000..e59c55fe1 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_openshiftcontrollermanager.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeOpenShiftControllerManagers implements OpenShiftControllerManagerInterface +type FakeOpenShiftControllerManagers struct { + Fake *FakeOperatorV1 +} + +var openshiftcontrollermanagersResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "openshiftcontrollermanagers"} + +var openshiftcontrollermanagersKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "OpenShiftControllerManager"} + +// Get takes name of the openShiftControllerManager, and returns the corresponding openShiftControllerManager object, and an error if there is any. +func (c *FakeOpenShiftControllerManagers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.OpenShiftControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(openshiftcontrollermanagersResource, name), &operatorv1.OpenShiftControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftControllerManager), err +} + +// List takes label and field selectors, and returns the list of OpenShiftControllerManagers that match those selectors. +func (c *FakeOpenShiftControllerManagers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.OpenShiftControllerManagerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(openshiftcontrollermanagersResource, openshiftcontrollermanagersKind, opts), &operatorv1.OpenShiftControllerManagerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.OpenShiftControllerManagerList{ListMeta: obj.(*operatorv1.OpenShiftControllerManagerList).ListMeta} + for _, item := range obj.(*operatorv1.OpenShiftControllerManagerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested openShiftControllerManagers. +func (c *FakeOpenShiftControllerManagers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(openshiftcontrollermanagersResource, opts)) +} + +// Create takes the representation of a openShiftControllerManager and creates it. Returns the server's representation of the openShiftControllerManager, and an error, if there is any. +func (c *FakeOpenShiftControllerManagers) Create(ctx context.Context, openShiftControllerManager *operatorv1.OpenShiftControllerManager, opts v1.CreateOptions) (result *operatorv1.OpenShiftControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(openshiftcontrollermanagersResource, openShiftControllerManager), &operatorv1.OpenShiftControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftControllerManager), err +} + +// Update takes the representation of a openShiftControllerManager and updates it. Returns the server's representation of the openShiftControllerManager, and an error, if there is any. +func (c *FakeOpenShiftControllerManagers) Update(ctx context.Context, openShiftControllerManager *operatorv1.OpenShiftControllerManager, opts v1.UpdateOptions) (result *operatorv1.OpenShiftControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(openshiftcontrollermanagersResource, openShiftControllerManager), &operatorv1.OpenShiftControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftControllerManager), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeOpenShiftControllerManagers) UpdateStatus(ctx context.Context, openShiftControllerManager *operatorv1.OpenShiftControllerManager, opts v1.UpdateOptions) (*operatorv1.OpenShiftControllerManager, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(openshiftcontrollermanagersResource, "status", openShiftControllerManager), &operatorv1.OpenShiftControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftControllerManager), err +} + +// Delete takes name of the openShiftControllerManager and deletes it. Returns an error if one occurs. +func (c *FakeOpenShiftControllerManagers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(openshiftcontrollermanagersResource, name), &operatorv1.OpenShiftControllerManager{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeOpenShiftControllerManagers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(openshiftcontrollermanagersResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.OpenShiftControllerManagerList{}) + return err +} + +// Patch applies the patch and returns the patched openShiftControllerManager. +func (c *FakeOpenShiftControllerManagers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.OpenShiftControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(openshiftcontrollermanagersResource, name, pt, data, subresources...), &operatorv1.OpenShiftControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.OpenShiftControllerManager), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_operator_client.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_operator_client.go new file mode 100644 index 000000000..7c41855b2 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_operator_client.go @@ -0,0 +1,84 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + v1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1" + rest "k8s.io/client-go/rest" + testing "k8s.io/client-go/testing" +) + +type FakeOperatorV1 struct { + *testing.Fake +} + +func (c *FakeOperatorV1) Authentications() v1.AuthenticationInterface { + return &FakeAuthentications{c} +} + +func (c *FakeOperatorV1) CSISnapshotControllers() v1.CSISnapshotControllerInterface { + return &FakeCSISnapshotControllers{c} +} + +func (c *FakeOperatorV1) Consoles() v1.ConsoleInterface { + return &FakeConsoles{c} +} + +func (c *FakeOperatorV1) DNSes() v1.DNSInterface { + return &FakeDNSes{c} +} + +func (c *FakeOperatorV1) Etcds() v1.EtcdInterface { + return &FakeEtcds{c} +} + +func (c *FakeOperatorV1) IngressControllers(namespace string) v1.IngressControllerInterface { + return &FakeIngressControllers{c, namespace} +} + +func (c *FakeOperatorV1) KubeAPIServers() v1.KubeAPIServerInterface { + return &FakeKubeAPIServers{c} +} + +func (c *FakeOperatorV1) KubeControllerManagers() v1.KubeControllerManagerInterface { + return &FakeKubeControllerManagers{c} +} + +func (c *FakeOperatorV1) KubeSchedulers() v1.KubeSchedulerInterface { + return &FakeKubeSchedulers{c} +} + +func (c *FakeOperatorV1) KubeStorageVersionMigrators() v1.KubeStorageVersionMigratorInterface { + return &FakeKubeStorageVersionMigrators{c} +} + +func (c *FakeOperatorV1) Networks() v1.NetworkInterface { + return &FakeNetworks{c} +} + +func (c *FakeOperatorV1) OpenShiftAPIServers() v1.OpenShiftAPIServerInterface { + return &FakeOpenShiftAPIServers{c} +} + +func (c *FakeOperatorV1) OpenShiftControllerManagers() v1.OpenShiftControllerManagerInterface { + return &FakeOpenShiftControllerManagers{c} +} + +func (c *FakeOperatorV1) ServiceCAs() v1.ServiceCAInterface { + return &FakeServiceCAs{c} +} + +func (c *FakeOperatorV1) ServiceCatalogAPIServers() v1.ServiceCatalogAPIServerInterface { + return &FakeServiceCatalogAPIServers{c} +} + +func (c *FakeOperatorV1) ServiceCatalogControllerManagers() v1.ServiceCatalogControllerManagerInterface { + return &FakeServiceCatalogControllerManagers{c} +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *FakeOperatorV1) RESTClient() rest.Interface { + var ret *rest.RESTClient + return ret +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_serviceca.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_serviceca.go new file mode 100644 index 000000000..22cefb2e6 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_serviceca.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeServiceCAs implements ServiceCAInterface +type FakeServiceCAs struct { + Fake *FakeOperatorV1 +} + +var servicecasResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "servicecas"} + +var servicecasKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "ServiceCA"} + +// Get takes name of the serviceCA, and returns the corresponding serviceCA object, and an error if there is any. +func (c *FakeServiceCAs) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.ServiceCA, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(servicecasResource, name), &operatorv1.ServiceCA{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCA), err +} + +// List takes label and field selectors, and returns the list of ServiceCAs that match those selectors. +func (c *FakeServiceCAs) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.ServiceCAList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(servicecasResource, servicecasKind, opts), &operatorv1.ServiceCAList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.ServiceCAList{ListMeta: obj.(*operatorv1.ServiceCAList).ListMeta} + for _, item := range obj.(*operatorv1.ServiceCAList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested serviceCAs. +func (c *FakeServiceCAs) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(servicecasResource, opts)) +} + +// Create takes the representation of a serviceCA and creates it. Returns the server's representation of the serviceCA, and an error, if there is any. +func (c *FakeServiceCAs) Create(ctx context.Context, serviceCA *operatorv1.ServiceCA, opts v1.CreateOptions) (result *operatorv1.ServiceCA, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(servicecasResource, serviceCA), &operatorv1.ServiceCA{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCA), err +} + +// Update takes the representation of a serviceCA and updates it. Returns the server's representation of the serviceCA, and an error, if there is any. +func (c *FakeServiceCAs) Update(ctx context.Context, serviceCA *operatorv1.ServiceCA, opts v1.UpdateOptions) (result *operatorv1.ServiceCA, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(servicecasResource, serviceCA), &operatorv1.ServiceCA{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCA), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeServiceCAs) UpdateStatus(ctx context.Context, serviceCA *operatorv1.ServiceCA, opts v1.UpdateOptions) (*operatorv1.ServiceCA, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(servicecasResource, "status", serviceCA), &operatorv1.ServiceCA{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCA), err +} + +// Delete takes name of the serviceCA and deletes it. Returns an error if one occurs. +func (c *FakeServiceCAs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(servicecasResource, name), &operatorv1.ServiceCA{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeServiceCAs) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(servicecasResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.ServiceCAList{}) + return err +} + +// Patch applies the patch and returns the patched serviceCA. +func (c *FakeServiceCAs) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.ServiceCA, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(servicecasResource, name, pt, data, subresources...), &operatorv1.ServiceCA{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCA), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogapiserver.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogapiserver.go new file mode 100644 index 000000000..ede8c3d66 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogapiserver.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeServiceCatalogAPIServers implements ServiceCatalogAPIServerInterface +type FakeServiceCatalogAPIServers struct { + Fake *FakeOperatorV1 +} + +var servicecatalogapiserversResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "servicecatalogapiservers"} + +var servicecatalogapiserversKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "ServiceCatalogAPIServer"} + +// Get takes name of the serviceCatalogAPIServer, and returns the corresponding serviceCatalogAPIServer object, and an error if there is any. +func (c *FakeServiceCatalogAPIServers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.ServiceCatalogAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(servicecatalogapiserversResource, name), &operatorv1.ServiceCatalogAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogAPIServer), err +} + +// List takes label and field selectors, and returns the list of ServiceCatalogAPIServers that match those selectors. +func (c *FakeServiceCatalogAPIServers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.ServiceCatalogAPIServerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(servicecatalogapiserversResource, servicecatalogapiserversKind, opts), &operatorv1.ServiceCatalogAPIServerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.ServiceCatalogAPIServerList{ListMeta: obj.(*operatorv1.ServiceCatalogAPIServerList).ListMeta} + for _, item := range obj.(*operatorv1.ServiceCatalogAPIServerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested serviceCatalogAPIServers. +func (c *FakeServiceCatalogAPIServers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(servicecatalogapiserversResource, opts)) +} + +// Create takes the representation of a serviceCatalogAPIServer and creates it. Returns the server's representation of the serviceCatalogAPIServer, and an error, if there is any. +func (c *FakeServiceCatalogAPIServers) Create(ctx context.Context, serviceCatalogAPIServer *operatorv1.ServiceCatalogAPIServer, opts v1.CreateOptions) (result *operatorv1.ServiceCatalogAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(servicecatalogapiserversResource, serviceCatalogAPIServer), &operatorv1.ServiceCatalogAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogAPIServer), err +} + +// Update takes the representation of a serviceCatalogAPIServer and updates it. Returns the server's representation of the serviceCatalogAPIServer, and an error, if there is any. +func (c *FakeServiceCatalogAPIServers) Update(ctx context.Context, serviceCatalogAPIServer *operatorv1.ServiceCatalogAPIServer, opts v1.UpdateOptions) (result *operatorv1.ServiceCatalogAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(servicecatalogapiserversResource, serviceCatalogAPIServer), &operatorv1.ServiceCatalogAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogAPIServer), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeServiceCatalogAPIServers) UpdateStatus(ctx context.Context, serviceCatalogAPIServer *operatorv1.ServiceCatalogAPIServer, opts v1.UpdateOptions) (*operatorv1.ServiceCatalogAPIServer, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(servicecatalogapiserversResource, "status", serviceCatalogAPIServer), &operatorv1.ServiceCatalogAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogAPIServer), err +} + +// Delete takes name of the serviceCatalogAPIServer and deletes it. Returns an error if one occurs. +func (c *FakeServiceCatalogAPIServers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(servicecatalogapiserversResource, name), &operatorv1.ServiceCatalogAPIServer{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeServiceCatalogAPIServers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(servicecatalogapiserversResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.ServiceCatalogAPIServerList{}) + return err +} + +// Patch applies the patch and returns the patched serviceCatalogAPIServer. +func (c *FakeServiceCatalogAPIServers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.ServiceCatalogAPIServer, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(servicecatalogapiserversResource, name, pt, data, subresources...), &operatorv1.ServiceCatalogAPIServer{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogAPIServer), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogcontrollermanager.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogcontrollermanager.go new file mode 100644 index 000000000..a0afe80b2 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake/fake_servicecatalogcontrollermanager.go @@ -0,0 +1,117 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + operatorv1 "github.com/openshift/api/operator/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeServiceCatalogControllerManagers implements ServiceCatalogControllerManagerInterface +type FakeServiceCatalogControllerManagers struct { + Fake *FakeOperatorV1 +} + +var servicecatalogcontrollermanagersResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1", Resource: "servicecatalogcontrollermanagers"} + +var servicecatalogcontrollermanagersKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1", Kind: "ServiceCatalogControllerManager"} + +// Get takes name of the serviceCatalogControllerManager, and returns the corresponding serviceCatalogControllerManager object, and an error if there is any. +func (c *FakeServiceCatalogControllerManagers) Get(ctx context.Context, name string, options v1.GetOptions) (result *operatorv1.ServiceCatalogControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(servicecatalogcontrollermanagersResource, name), &operatorv1.ServiceCatalogControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogControllerManager), err +} + +// List takes label and field selectors, and returns the list of ServiceCatalogControllerManagers that match those selectors. +func (c *FakeServiceCatalogControllerManagers) List(ctx context.Context, opts v1.ListOptions) (result *operatorv1.ServiceCatalogControllerManagerList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(servicecatalogcontrollermanagersResource, servicecatalogcontrollermanagersKind, opts), &operatorv1.ServiceCatalogControllerManagerList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &operatorv1.ServiceCatalogControllerManagerList{ListMeta: obj.(*operatorv1.ServiceCatalogControllerManagerList).ListMeta} + for _, item := range obj.(*operatorv1.ServiceCatalogControllerManagerList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested serviceCatalogControllerManagers. +func (c *FakeServiceCatalogControllerManagers) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(servicecatalogcontrollermanagersResource, opts)) +} + +// Create takes the representation of a serviceCatalogControllerManager and creates it. Returns the server's representation of the serviceCatalogControllerManager, and an error, if there is any. +func (c *FakeServiceCatalogControllerManagers) Create(ctx context.Context, serviceCatalogControllerManager *operatorv1.ServiceCatalogControllerManager, opts v1.CreateOptions) (result *operatorv1.ServiceCatalogControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(servicecatalogcontrollermanagersResource, serviceCatalogControllerManager), &operatorv1.ServiceCatalogControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogControllerManager), err +} + +// Update takes the representation of a serviceCatalogControllerManager and updates it. Returns the server's representation of the serviceCatalogControllerManager, and an error, if there is any. +func (c *FakeServiceCatalogControllerManagers) Update(ctx context.Context, serviceCatalogControllerManager *operatorv1.ServiceCatalogControllerManager, opts v1.UpdateOptions) (result *operatorv1.ServiceCatalogControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(servicecatalogcontrollermanagersResource, serviceCatalogControllerManager), &operatorv1.ServiceCatalogControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogControllerManager), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeServiceCatalogControllerManagers) UpdateStatus(ctx context.Context, serviceCatalogControllerManager *operatorv1.ServiceCatalogControllerManager, opts v1.UpdateOptions) (*operatorv1.ServiceCatalogControllerManager, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(servicecatalogcontrollermanagersResource, "status", serviceCatalogControllerManager), &operatorv1.ServiceCatalogControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogControllerManager), err +} + +// Delete takes name of the serviceCatalogControllerManager and deletes it. Returns an error if one occurs. +func (c *FakeServiceCatalogControllerManagers) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(servicecatalogcontrollermanagersResource, name), &operatorv1.ServiceCatalogControllerManager{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeServiceCatalogControllerManagers) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(servicecatalogcontrollermanagersResource, listOpts) + + _, err := c.Fake.Invokes(action, &operatorv1.ServiceCatalogControllerManagerList{}) + return err +} + +// Patch applies the patch and returns the patched serviceCatalogControllerManager. +func (c *FakeServiceCatalogControllerManagers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *operatorv1.ServiceCatalogControllerManager, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(servicecatalogcontrollermanagersResource, name, pt, data, subresources...), &operatorv1.ServiceCatalogControllerManager{}) + if obj == nil { + return nil, err + } + return obj.(*operatorv1.ServiceCatalogControllerManager), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/doc.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/doc.go new file mode 100644 index 000000000..2b5ba4c8e --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/doc.go @@ -0,0 +1,4 @@ +// Code generated by client-gen. DO NOT EDIT. + +// Package fake has the automatically generated clients. +package fake diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_imagecontentsourcepolicy.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_imagecontentsourcepolicy.go new file mode 100644 index 000000000..e2e0cd14f --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_imagecontentsourcepolicy.go @@ -0,0 +1,106 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + v1alpha1 "github.com/openshift/api/operator/v1alpha1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeImageContentSourcePolicies implements ImageContentSourcePolicyInterface +type FakeImageContentSourcePolicies struct { + Fake *FakeOperatorV1alpha1 +} + +var imagecontentsourcepoliciesResource = schema.GroupVersionResource{Group: "operator.openshift.io", Version: "v1alpha1", Resource: "imagecontentsourcepolicies"} + +var imagecontentsourcepoliciesKind = schema.GroupVersionKind{Group: "operator.openshift.io", Version: "v1alpha1", Kind: "ImageContentSourcePolicy"} + +// Get takes name of the imageContentSourcePolicy, and returns the corresponding imageContentSourcePolicy object, and an error if there is any. +func (c *FakeImageContentSourcePolicies) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(imagecontentsourcepoliciesResource, name), &v1alpha1.ImageContentSourcePolicy{}) + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ImageContentSourcePolicy), err +} + +// List takes label and field selectors, and returns the list of ImageContentSourcePolicies that match those selectors. +func (c *FakeImageContentSourcePolicies) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.ImageContentSourcePolicyList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(imagecontentsourcepoliciesResource, imagecontentsourcepoliciesKind, opts), &v1alpha1.ImageContentSourcePolicyList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &v1alpha1.ImageContentSourcePolicyList{ListMeta: obj.(*v1alpha1.ImageContentSourcePolicyList).ListMeta} + for _, item := range obj.(*v1alpha1.ImageContentSourcePolicyList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested imageContentSourcePolicies. +func (c *FakeImageContentSourcePolicies) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(imagecontentsourcepoliciesResource, opts)) +} + +// Create takes the representation of a imageContentSourcePolicy and creates it. Returns the server's representation of the imageContentSourcePolicy, and an error, if there is any. +func (c *FakeImageContentSourcePolicies) Create(ctx context.Context, imageContentSourcePolicy *v1alpha1.ImageContentSourcePolicy, opts v1.CreateOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(imagecontentsourcepoliciesResource, imageContentSourcePolicy), &v1alpha1.ImageContentSourcePolicy{}) + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ImageContentSourcePolicy), err +} + +// Update takes the representation of a imageContentSourcePolicy and updates it. Returns the server's representation of the imageContentSourcePolicy, and an error, if there is any. +func (c *FakeImageContentSourcePolicies) Update(ctx context.Context, imageContentSourcePolicy *v1alpha1.ImageContentSourcePolicy, opts v1.UpdateOptions) (result *v1alpha1.ImageContentSourcePolicy, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(imagecontentsourcepoliciesResource, imageContentSourcePolicy), &v1alpha1.ImageContentSourcePolicy{}) + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ImageContentSourcePolicy), err +} + +// Delete takes name of the imageContentSourcePolicy and deletes it. Returns an error if one occurs. +func (c *FakeImageContentSourcePolicies) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(imagecontentsourcepoliciesResource, name), &v1alpha1.ImageContentSourcePolicy{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeImageContentSourcePolicies) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(imagecontentsourcepoliciesResource, listOpts) + + _, err := c.Fake.Invokes(action, &v1alpha1.ImageContentSourcePolicyList{}) + return err +} + +// Patch applies the patch and returns the patched imageContentSourcePolicy. +func (c *FakeImageContentSourcePolicies) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.ImageContentSourcePolicy, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(imagecontentsourcepoliciesResource, name, pt, data, subresources...), &v1alpha1.ImageContentSourcePolicy{}) + if obj == nil { + return nil, err + } + return obj.(*v1alpha1.ImageContentSourcePolicy), err +} diff --git a/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go new file mode 100644 index 000000000..4759c1283 --- /dev/null +++ b/vendor/github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake/fake_operator_client.go @@ -0,0 +1,24 @@ +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + v1alpha1 "github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1" + rest "k8s.io/client-go/rest" + testing "k8s.io/client-go/testing" +) + +type FakeOperatorV1alpha1 struct { + *testing.Fake +} + +func (c *FakeOperatorV1alpha1) ImageContentSourcePolicies() v1alpha1.ImageContentSourcePolicyInterface { + return &FakeImageContentSourcePolicies{c} +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *FakeOperatorV1alpha1) RESTClient() rest.Interface { + var ret *rest.RESTClient + return ret +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 21d465859..8ea76d0d8 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -158,9 +158,12 @@ github.com/openshift/client-go/oauth/clientset/versioned github.com/openshift/client-go/oauth/clientset/versioned/scheme github.com/openshift/client-go/oauth/clientset/versioned/typed/oauth/v1 github.com/openshift/client-go/operator/clientset/versioned +github.com/openshift/client-go/operator/clientset/versioned/fake github.com/openshift/client-go/operator/clientset/versioned/scheme github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1 +github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1/fake github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1 +github.com/openshift/client-go/operator/clientset/versioned/typed/operator/v1alpha1/fake github.com/openshift/client-go/operator/informers/externalversions github.com/openshift/client-go/operator/informers/externalversions/internalinterfaces github.com/openshift/client-go/operator/informers/externalversions/operator From d58e30090dacfe236896b841214892971796ffbf Mon Sep 17 00:00:00 2001 From: Lukasz Szaszkiewicz Date: Thu, 6 Aug 2020 12:43:36 +0200 Subject: [PATCH 3/5] adds OAuthAPIServerCleanerController for deleting openshift-oauth-apiserver ns --- .../oauth_apiserver_pruner.go | 137 +++++++++++ .../oauth_apiserver_pruner_test.go | 213 ++++++++++++++++++ 2 files changed, 350 insertions(+) create mode 100644 pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner.go create mode 100644 pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner_test.go diff --git a/pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner.go b/pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner.go new file mode 100644 index 000000000..bdd1b2ef4 --- /dev/null +++ b/pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner.go @@ -0,0 +1,137 @@ +package oauthapiserverpruner + +import ( + "context" + + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/sets" + corev1client "k8s.io/client-go/kubernetes/typed/core/v1" + corev1listers "k8s.io/client-go/listers/core/v1" + "k8s.io/klog" + apiregistrationv1informer "k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1" + apiregistrationv1lister "k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1" + + operatorclientinformers "github.com/openshift/client-go/operator/informers/externalversions" + operatorlistersv1 "github.com/openshift/client-go/operator/listers/operator/v1" + "github.com/openshift/library-go/pkg/controller/factory" + "github.com/openshift/library-go/pkg/operator/encryption/secrets" + "github.com/openshift/library-go/pkg/operator/events" + "github.com/openshift/library-go/pkg/operator/v1helpers" +) + +const ( + OAuthApiServerNsToRemove = "openshift-oauth-apiserver" +) + +type oauthAPIServerPrunerController struct { + apiServicesManagedByOAS []string + + namespaceClient corev1client.NamespaceInterface + secretClient corev1client.SecretInterface + + apiregistrationv1Lister apiregistrationv1lister.APIServiceLister + authOperatorLister operatorlistersv1.AuthenticationLister + namespaceLister corev1listers.NamespaceLister +} + +// NewOAuthAPIServerPrunerController removes "openshift-oauth-apiserver" namespace. +// +// The namespace holds the OAuth API Server and all necessary resources that are valid only for 4.6+ clusters +// This controller is intended to clean up in case of a downgrade from 4.6 to 4.5. +func NewOAuthAPIServerPrunerController( + name string, + apiServicesManagedByOAS []string, + kubeClient corev1client.CoreV1Interface, + kubeInformersForNamespaces v1helpers.KubeInformersForNamespaces, + authOperatorInformers operatorclientinformers.SharedInformerFactory, + apiregistrationv1Informer apiregistrationv1informer.APIServiceInformer, + eventRecorder events.Recorder) factory.Controller { + + authInformers := authOperatorInformers.Operator().V1().Authentications() + + c := &oauthAPIServerPrunerController{ + apiServicesManagedByOAS: apiServicesManagedByOAS, + namespaceClient: kubeClient.Namespaces(), + secretClient: kubeClient.Secrets(OAuthApiServerNsToRemove), + apiregistrationv1Lister: apiregistrationv1Informer.Lister(), + authOperatorLister: authInformers.Lister(), + namespaceLister: kubeInformersForNamespaces.InformersFor("").Core().V1().Namespaces().Lister(), + } + + controllerFactory := factory.New() + controllerFactory.WithInformers(authInformers.Informer(), kubeInformersForNamespaces.InformersFor("").Core().V1().Namespaces().Informer(), apiregistrationv1Informer.Informer()) + controllerFactory.WithSync(c.sync) + + return controllerFactory.ToController(name, eventRecorder.WithComponentSuffix("oauth-apiserver-cleaner-controller")) +} + +func (c *oauthAPIServerPrunerController) sync(ctx context.Context, _ factory.SyncContext) error { + // check the ManagingOAuthAPIServer field + operator, err := c.authOperatorLister.Get("cluster") + if err != nil { + return err + } + + if operator.Status.ManagingOAuthAPIServer { + klog.V(2).Info("waiting for ManagingOAuthAPIServer field to be set to false") + return nil // we will be called again once the operator status changes + } + + // be graceful and check if the API Services that were managed by CAO in 4.6 are now being managed by OAS-O + for _, apiServiceName := range c.apiServicesManagedByOAS { + managedByOAS, err := c.isAPIServiceMangedByOAS(apiServiceName) + if err != nil { + return err + } + if !managedByOAS { + klog.V(2).Infof("waiting for the api service %s to be managed by OAS-O", apiServiceName) + return nil // we will be called again once the api services change + } + } + + // remove the namespace + if _, err := c.namespaceLister.Get(OAuthApiServerNsToRemove); err != nil { + if errors.IsNotFound(err) { + return nil // no-op the namespace was already removed + } + return err + } + if err := c.namespaceClient.Delete(ctx, OAuthApiServerNsToRemove, metav1.DeleteOptions{}); err != nil { + return err + } + + // remove the finalizer from the encryption config secrets (encryption-config ,encryption-config-REVISION) + // otherwise the namespace won't be removed + allSecrets, err := c.secretClient.List(ctx, metav1.ListOptions{}) + if err != nil { + return err + } + var finalizerDeletionErrs []error + for _, secret := range allSecrets.Items { + if finalizers := sets.NewString(secret.Finalizers...); finalizers.Has(secrets.EncryptionSecretFinalizer) { + delete(finalizers, secrets.EncryptionSecretFinalizer) + secret.Finalizers = finalizers.List() + if _, err := c.secretClient.Update(ctx, &secret, metav1.UpdateOptions{}); err != nil { + finalizerDeletionErrs = append(finalizerDeletionErrs, err) + } + } + } + return utilerrors.NewAggregate(finalizerDeletionErrs) +} + +func (c *oauthAPIServerPrunerController) isAPIServiceMangedByOAS(apiServiceName string) (bool, error) { + existingApiService, err := c.apiregistrationv1Lister.Get(apiServiceName) + if err != nil { + return false, err + } + + // we don't check the "authentication.operator.openshift.io/managed" annotation because it is only set by CAO (4.6) to true. + // there is no component that sets it back to false or removes it + if existingApiService.Spec.Service != nil && existingApiService.Spec.Service.Namespace != OAuthApiServerNsToRemove { + return true, nil + } + + return false, nil +} diff --git a/pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner_test.go b/pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner_test.go new file mode 100644 index 000000000..7d779981d --- /dev/null +++ b/pkg/controller/oauthapiserverpruner/oauth_apiserver_pruner_test.go @@ -0,0 +1,213 @@ +package oauthapiserverpruner + +import ( + "context" + "fmt" + "testing" + + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + fakekube "k8s.io/client-go/kubernetes/fake" + corev1listers "k8s.io/client-go/listers/core/v1" + clientgotesting "k8s.io/client-go/testing" + "k8s.io/client-go/tools/cache" + apiregistrationv1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1" + apiregistrationv1lister "k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1" + + operatorv1 "github.com/openshift/api/operator/v1" + operatorlistersv1 "github.com/openshift/client-go/operator/listers/operator/v1" + "github.com/openshift/library-go/pkg/controller/factory" + "github.com/openshift/library-go/pkg/operator/events" +) + +func TestOAuthAPIServerPrunerController(t *testing.T) { + scenarios := []struct { + name string + setManagingOAuthAPIServer bool + apiServicesToMange []*apiregistrationv1.APIService + existingNs *v1.Namespace + existingSecrets []*v1.Secret + expectError bool + expectedActions []string + }{ + { + name: "no-op because ManagingOAuthAPIServer not set", + setManagingOAuthAPIServer: true, + }, + + { + name: "no-op because the api services are managed by CAO", + apiServicesToMange: []*apiregistrationv1.APIService{ + newAPIService("user.openshift.io", "v1", "openshift-oauth-apiserver"), + newAPIService("oauth.openshift.io", "v1", "openshift-oauth-apiserver"), + }, + }, + + { + name: "no-op the namespace already removed", + apiServicesToMange: []*apiregistrationv1.APIService{ + newAPIService("user.openshift.io", "v1", "openshift-apiserver"), + newAPIService("oauth.openshift.io", "v1", "openshift-apiserver"), + }, + }, + + { + name: "the namespace is removed", + apiServicesToMange: []*apiregistrationv1.APIService{ + newAPIService("user.openshift.io", "v1", "openshift-apiserver"), + newAPIService("oauth.openshift.io", "v1", "openshift-apiserver"), + }, + existingNs: newNamespace("openshift-oauth-apiserver"), + expectedActions: []string{"delete:namespaces:", "list:secrets:openshift-oauth-apiserver"}, + }, + + { + name: "the namespace is removed and the annotation from the secrets", + apiServicesToMange: []*apiregistrationv1.APIService{ + newAPIService("user.openshift.io", "v1", "openshift-apiserver"), + newAPIService("oauth.openshift.io", "v1", "openshift-apiserver"), + }, + existingNs: newNamespace("openshift-oauth-apiserver"), + existingSecrets: []*v1.Secret{ + newSecret("openshift-oauth-apiserver"), + }, + expectedActions: []string{"delete:namespaces:", "list:secrets:openshift-oauth-apiserver", "update:secrets:openshift-oauth-apiserver"}, + }, + + { + name: "the namespace is removed", + apiServicesToMange: []*apiregistrationv1.APIService{ + newAPIService("user.openshift.io", "v1", "openshift-apiserver"), + newAPIService("oauth.openshift.io", "v1", "openshift-apiserver"), + }, + existingNs: newNamespace("openshift-oauth-apiserver"), + existingSecrets: []*v1.Secret{ + func() *v1.Secret { + s := newSecret("openshift-oauth-apiserver") + s.Finalizers = []string{} + return s + }(), + }, + expectedActions: []string{"delete:namespaces:", "list:secrets:openshift-oauth-apiserver"}, + }, + } + for _, scenario := range scenarios { + t.Run(scenario.name, func(t *testing.T) { + // set up + initialObjects := []runtime.Object{} + eventRecorder := events.NewInMemoryRecorder("") + syncContext := factory.NewSyncContext("", eventRecorder) + fakeAuthOperatorIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}) + { + authOperator := &operatorv1.Authentication{ + TypeMeta: metav1.TypeMeta{}, + ObjectMeta: metav1.ObjectMeta{Name: "cluster"}, + Spec: operatorv1.AuthenticationSpec{OperatorSpec: operatorv1.OperatorSpec{ManagementState: operatorv1.Managed}}, + Status: operatorv1.AuthenticationStatus{OperatorStatus: operatorv1.OperatorStatus{}, ManagingOAuthAPIServer: scenario.setManagingOAuthAPIServer}, + } + + err := fakeAuthOperatorIndexer.Add(authOperator) + if err != nil { + t.Fatal(err) + } + } + fakeAPIregistrationIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}) + { + for _, apiService := range scenario.apiServicesToMange { + err := fakeAPIregistrationIndexer.Add(apiService) + if err != nil { + t.Fatal(err) + } + } + } + fakeNamespaceIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{}) + { + if scenario.existingNs != nil { + err := fakeNamespaceIndexer.Add(scenario.existingNs) + if err != nil { + t.Fatal(err) + } + initialObjects = append(initialObjects, scenario.existingNs) + } + } + for _, existingSecret := range scenario.existingSecrets { + initialObjects = append(initialObjects, existingSecret) + } + fakeKubeClient := fakekube.NewSimpleClientset(initialObjects...) + + // act + target := &oauthAPIServerPrunerController{ + authOperatorLister: operatorlistersv1.NewAuthenticationLister(fakeAuthOperatorIndexer), + apiregistrationv1Lister: apiregistrationv1lister.NewAPIServiceLister(fakeAPIregistrationIndexer), + namespaceLister: corev1listers.NewNamespaceLister(fakeNamespaceIndexer), + secretClient: fakeKubeClient.CoreV1().Secrets("openshift-oauth-apiserver"), + namespaceClient: fakeKubeClient.CoreV1().Namespaces(), + apiServicesManagedByOAS: []string{"v1.oauth.openshift.io", "v1.user.openshift.io"}, + } + err := target.sync(context.TODO(), syncContext) + + // validate + if err != nil && !scenario.expectError { + t.Fatalf("unexpected error returned %v", err) + } + if err == nil && scenario.expectError { + t.Fatal("expected an error") + } + + if err = validateActionsVerbs(fakeKubeClient.Actions(), scenario.expectedActions); err != nil { + t.Fatal(err) + } + }) + } +} + +func validateActionsVerbs(actualActions []clientgotesting.Action, expectedActions []string) error { + if len(actualActions) != len(expectedActions) { + return fmt.Errorf("expected to get %d actions but got %d\nexpected=%v \n got=%v", len(expectedActions), len(actualActions), expectedActions, actionStrings(actualActions)) + } + for i, a := range actualActions { + if got, expected := actionString(a), expectedActions[i]; got != expected { + return fmt.Errorf("at %d got %s, expected %s", i, got, expected) + } + } + return nil +} + +func actionString(a clientgotesting.Action) string { + return a.GetVerb() + ":" + a.GetResource().Resource + ":" + a.GetNamespace() +} + +func actionStrings(actions []clientgotesting.Action) []string { + res := make([]string, 0, len(actions)) + for _, a := range actions { + res = append(res, actionString(a)) + } + return res +} + +func newAPIService(group, version, svcNs string) *apiregistrationv1.APIService { + return &apiregistrationv1.APIService{ + ObjectMeta: metav1.ObjectMeta{Name: version + "." + group, Annotations: map[string]string{"service.alpha.openshift.io/inject-cabundle": "true"}}, + Spec: apiregistrationv1.APIServiceSpec{Group: group, Version: version, Service: &apiregistrationv1.ServiceReference{Namespace: svcNs, Name: "api"}, GroupPriorityMinimum: 9900, VersionPriority: 15}, + Status: apiregistrationv1.APIServiceStatus{Conditions: []apiregistrationv1.APIServiceCondition{{Type: apiregistrationv1.Available, Status: apiregistrationv1.ConditionTrue}}}, + } +} + +func newNamespace(name string) *v1.Namespace { + return &v1.Namespace{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + }, + } +} + +func newSecret(ns string) *v1.Secret { + return &v1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("encryption-key-%s", ns), + Namespace: ns, + Finalizers: []string{"encryption.apiserver.operator.openshift.io/deletion-protection"}, + }, + } +} From 7adcf946e5c444ed26ce9ef74e35dae85079ba9a Mon Sep 17 00:00:00 2001 From: Lukasz Szaszkiewicz Date: Thu, 6 Aug 2020 13:11:49 +0200 Subject: [PATCH 4/5] wires OAuthAPIServerCleanerController and removes stale conditions --- pkg/operator2/starter.go | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/pkg/operator2/starter.go b/pkg/operator2/starter.go index 3d04fac72..a77c9fee2 100644 --- a/pkg/operator2/starter.go +++ b/pkg/operator2/starter.go @@ -7,6 +7,8 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/fields" "k8s.io/client-go/kubernetes" + apiregistrationclient "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset" + apiregistrationinformers "k8s.io/kube-aggregator/pkg/client/informers/externalversions" configv1 "github.com/openshift/api/config/v1" operatorv1 "github.com/openshift/api/operator/v1" @@ -31,6 +33,7 @@ import ( "github.com/openshift/cluster-authentication-operator/pkg/controller/apiservices" "github.com/openshift/cluster-authentication-operator/pkg/controller/ingressstate" + "github.com/openshift/cluster-authentication-operator/pkg/controller/oauthapiserverpruner" "github.com/openshift/cluster-authentication-operator/pkg/operator2/assets" "github.com/openshift/cluster-authentication-operator/pkg/operator2/configobservation/configobservercontroller" "github.com/openshift/cluster-authentication-operator/pkg/operator2/routercerts" @@ -69,11 +72,19 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle return err } + apiregistrationv1Client, err := apiregistrationclient.NewForConfig(controllerContext.ProtoKubeConfig) + if err != nil { + return err + } + kubeInformersNamespaced := v1helpers.NewKubeInformersForNamespaces(kubeClient, "openshift-authentication", "kube-system", + "", // an informer for non-namespaced resources ) + apiregistrationInformers := apiregistrationinformers.NewSharedInformerFactory(apiregistrationv1Client, 10*time.Minute) + // short resync period as this drives the check frequency when checking the .well-known endpoint. 20 min is too slow for that. authOperatorInformers := authopinformer.NewSharedInformerFactoryWithOptions(authOperatorClient, time.Second*30, authopinformer.WithTweakListOptions(singleNameListOptions("cluster")), @@ -201,6 +212,14 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle // As of 4.4, this will appear as a configObserver error "FailedRouterSecret", + + // Added by CAO in 4.6, we need to clean up on a downgrade + "APIServicesAvailable", + "APIServerStaticResourcesDegraded", + "APIServerDeploymentAvailable", + "APIServerDeploymentDegraded", + "APIServerDeploymentProgressing", + "APIServerWorkloadDegraded", }, operatorClient, controllerContext.EventRecorder, @@ -234,6 +253,16 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle controllerContext.EventRecorder, ) + oauthAPIServerCleanerController := oauthapiserverpruner.NewOAuthAPIServerPrunerController( + "OAuthAPIServerPruner", + []string{"v1.oauth.openshift.io", "v1.user.openshift.io"}, + kubeClient.CoreV1(), + kubeInformersNamespaced, + authOperatorInformers, + apiregistrationInformers.Apiregistration().V1().APIServices(), + controllerContext.EventRecorder, + ) + // TODO remove this controller once we support Removed managementStateController := management.NewOperatorManagementStateController("authentication", operatorClient, controllerContext.EventRecorder) management.SetOperatorNotRemovable() @@ -246,6 +275,7 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle routeInformersNamespaced, configInformers, resourceSyncerInformers, + apiregistrationInformers, } { informer.Start(ctx.Done()) } @@ -263,6 +293,7 @@ func RunOperator(ctx context.Context, controllerContext *controllercmd.Controlle routerCertsController, staleConditions, staticResourceController, + oauthAPIServerCleanerController, } { go controller.Run(ctx, 1) } From 885d005e5b3a4dc8a92532beca6a470bdba85745 Mon Sep 17 00:00:00 2001 From: Lukasz Szaszkiewicz Date: Thu, 6 Aug 2020 12:44:03 +0200 Subject: [PATCH 5/5] go mod vendor --- go.mod | 11 +- go.sum | 15 ++ .../operator/encryption/secrets/secrets.go | 140 +++++++++++++ .../pkg/operator/encryption/secrets/types.go | 59 ++++++ .../pkg/operator/encryption/state/helpers.go | 84 ++++++++ .../pkg/operator/encryption/state/types.go | 69 +++++++ .../apimachinery/pkg/apis/meta/v1/types.go | 3 + .../pkg/apis/meta/v1/validation/validation.go | 2 +- .../k8s.io/apimachinery/pkg/util/json/json.go | 25 +++ .../k8s.io/apimachinery/pkg/util/net/http.go | 2 +- .../k8s.io/apimachinery/pkg/util/wait/wait.go | 27 ++- .../pkg/endpoints/handlers/create.go | 5 +- .../handlers/fieldmanager/fieldmanager.go | 62 +++++- .../fieldmanager/internal/managedfields.go | 28 +-- .../handlers/fieldmanager/structuredmerge.go | 15 +- .../apiserver/pkg/endpoints/handlers/patch.go | 8 +- .../pkg/endpoints/handlers/update.go | 6 +- .../pkg/endpoints/metrics/metrics.go | 59 +++++- vendor/k8s.io/apiserver/pkg/server/config.go | 22 ++- .../apiserver/pkg/server/healthz/healthz.go | 34 ++++ vendor/k8s.io/apiserver/pkg/storage/errors.go | 19 +- .../k8s.io/client-go/tools/cache/reflector.go | 39 ++-- .../tools/clientcmd/client_config.go | 11 +- .../resourcelock/configmaplock.go | 3 + .../clientset/clientset.go | 111 +++++++++++ .../clientset_generated/clientset/doc.go | 20 ++ .../v1beta1/apiregistration_client.go | 89 +++++++++ .../apiregistration/v1beta1/apiservice.go | 184 ++++++++++++++++++ .../typed/apiregistration/v1beta1/doc.go | 20 ++ .../v1beta1/generated_expansion.go | 21 ++ .../apiregistration/interface.go | 54 +++++ .../apiregistration/v1/apiservice.go | 89 +++++++++ .../apiregistration/v1/interface.go | 45 +++++ .../apiregistration/v1beta1/apiservice.go | 89 +++++++++ .../apiregistration/v1beta1/interface.go | 45 +++++ .../informers/externalversions/factory.go | 180 +++++++++++++++++ .../informers/externalversions/generic.go | 67 +++++++ .../internalinterfaces/factory_interfaces.go | 40 ++++ .../listers/apiregistration/v1/apiservice.go | 65 +++++++ .../apiregistration/v1/expansion_generated.go | 23 +++ .../apiregistration/v1beta1/apiservice.go | 65 +++++++ .../v1beta1/expansion_generated.go | 23 +++ vendor/modules.txt | 25 ++- 43 files changed, 1895 insertions(+), 108 deletions(-) create mode 100644 vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/secrets.go create mode 100644 vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/types.go create mode 100644 vendor/github.com/openshift/library-go/pkg/operator/encryption/state/helpers.go create mode 100644 vendor/github.com/openshift/library-go/pkg/operator/encryption/state/types.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/doc.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiregistration_client.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiservice.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/doc.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/generated_expansion.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/interface.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/apiservice.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/interface.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/apiservice.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/interface.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/factory.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/generic.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/apiservice.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/expansion_generated.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/apiservice.go create mode 100644 vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/expansion_generated.go diff --git a/go.mod b/go.mod index effbf7f96..375920b9c 100644 --- a/go.mod +++ b/go.mod @@ -17,11 +17,12 @@ require ( go.uber.org/multierr v1.1.1-0.20180122172545-ddea229ff1df // indirect gopkg.in/square/go-jose.v2 v2.2.2 gopkg.in/yaml.v2 v2.2.8 - k8s.io/api v0.18.2 - k8s.io/apimachinery v0.18.2 - k8s.io/apiserver v0.18.2 - k8s.io/client-go v0.18.2 - k8s.io/component-base v0.18.2 + k8s.io/api v0.18.6 + k8s.io/apimachinery v0.18.6 + k8s.io/apiserver v0.18.6 + k8s.io/client-go v0.18.6 + k8s.io/component-base v0.18.6 k8s.io/klog v1.0.0 + k8s.io/kube-aggregator v0.18.6 monis.app/go v0.0.0-20190702030534-c65526068664 ) diff --git a/go.sum b/go.sum index 8291c9aa9..6ea03e797 100644 --- a/go.sum +++ b/go.sum @@ -521,6 +521,8 @@ k8s.io/api v0.18.0 h1:lwYk8Vt7rsVTwjRU6pzEsa9YNhThbmbocQlKvNBB4EQ= k8s.io/api v0.18.0/go.mod h1:q2HRQkfDzHMBZL9l/y9rH63PkQl4vae0xRT+8prbrK8= k8s.io/api v0.18.2 h1:wG5g5ZmSVgm5B+eHMIbI9EGATS2L8Z72rda19RIEgY8= k8s.io/api v0.18.2/go.mod h1:SJCWI7OLzhZSvbY7U8zwNl9UA4o1fizoug34OV/2r78= +k8s.io/api v0.18.6 h1:osqrAXbOQjkKIWDTjrqxWQ3w0GkKb1KA1XkUGHHYpeE= +k8s.io/api v0.18.6/go.mod h1:eeyxr+cwCjMdLAmr2W3RyDI0VvTawSg/3RFFBEnmZGI= k8s.io/apiextensions-apiserver v0.18.2 h1:I4v3/jAuQC+89L3Z7dDgAiN4EOjN6sbm6iBqQwHTah8= k8s.io/apiextensions-apiserver v0.18.2/go.mod h1:q3faSnRGmYimiocj6cHQ1I3WpLqmDgJFlKL37fC4ZvY= k8s.io/apimachinery v0.0.0-20190221213512-86fb29eff628/go.mod h1:ccL7Eh7zubPUSh9A3USN90/OzHNSVN6zxzde07TDCL0= @@ -528,17 +530,26 @@ k8s.io/apimachinery v0.18.0 h1:fuPfYpk3cs1Okp/515pAf0dNhL66+8zk8RLbSX+EgAE= k8s.io/apimachinery v0.18.0/go.mod h1:9SnR/e11v5IbyPCGbvJViimtJ0SwHG4nfZFjU77ftcA= k8s.io/apimachinery v0.18.2 h1:44CmtbmkzVDAhCpRVSiP2R5PPrC2RtlIv/MoB8xpdRA= k8s.io/apimachinery v0.18.2/go.mod h1:9SnR/e11v5IbyPCGbvJViimtJ0SwHG4nfZFjU77ftcA= +k8s.io/apimachinery v0.18.6 h1:RtFHnfGNfd1N0LeSrKCUznz5xtUP1elRGvHJbL3Ntag= +k8s.io/apimachinery v0.18.6/go.mod h1:OaXp26zu/5J7p0f92ASynJa1pZo06YlV9fG7BoWbCko= k8s.io/apiserver v0.18.2 h1:fwKxdTWwwYhxvtjo0UUfX+/fsitsNtfErPNegH2x9ic= k8s.io/apiserver v0.18.2/go.mod h1:Xbh066NqrZO8cbsoenCwyDJ1OSi8Ag8I2lezeHxzwzw= +k8s.io/apiserver v0.18.6 h1:HcWwcOfhj4Yv6y2igP4ZUuovyPjVLGoZcG0Tsph4Mxo= +k8s.io/apiserver v0.18.6/go.mod h1:Zt2XvTHuaZjBz6EFYzpp+X4hTmgWGy8AthNVnTdm3Wg= k8s.io/client-go v0.0.0-20190228174230-b40b2a5939e4/go.mod h1:7vJpHMYJwNQCWgzmNV+VYUl1zCObLyodBc8nIyt8L5s= k8s.io/client-go v0.18.0 h1:yqKw4cTUQraZK3fcVCMeSa+lqKwcjZ5wtcOIPnxQno4= k8s.io/client-go v0.18.0/go.mod h1:uQSYDYs4WhVZ9i6AIoEZuwUggLVEF64HOD37boKAtF8= k8s.io/client-go v0.18.2 h1:aLB0iaD4nmwh7arT2wIn+lMnAq7OswjaejkQ8p9bBYE= k8s.io/client-go v0.18.2/go.mod h1:Xcm5wVGXX9HAA2JJ2sSBUn3tCJ+4SVlCbl2MNNv+CIU= +k8s.io/client-go v0.18.6 h1:I+oWqJbibLSGsZj8Xs8F0aWVXJVIoUHWaaJV3kUN/Zw= +k8s.io/client-go v0.18.6/go.mod h1:/fwtGLjYMS1MaM5oi+eXhKwG+1UHidUEXRh6cNsdO0Q= k8s.io/code-generator v0.18.0/go.mod h1:+UHX5rSbxmR8kzS+FAv7um6dtYrZokQvjHpDSYRVkTc= k8s.io/code-generator v0.18.2/go.mod h1:+UHX5rSbxmR8kzS+FAv7um6dtYrZokQvjHpDSYRVkTc= +k8s.io/code-generator v0.18.6/go.mod h1:TgNEVx9hCyPGpdtCWA34olQYLkh3ok9ar7XfSsr8b6c= k8s.io/component-base v0.18.2 h1:SJweNZAGcUvsypLGNPNGeJ9UgPZQ6+bW+gEHe8uyh/Y= k8s.io/component-base v0.18.2/go.mod h1:kqLlMuhJNHQ9lz8Z7V5bxUUtjFZnrypArGl58gmDfUM= +k8s.io/component-base v0.18.6 h1:Wd6cHGwJN2qpufnirVOB3oMhyhbioGsKEi5HeDBsV+s= +k8s.io/component-base v0.18.6/go.mod h1:knSVsibPR5K6EW2XOjEHik6sdU5nCvKMrzMt2D4In14= k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= k8s.io/gengo v0.0.0-20200114144118-36b2048a9120/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk= @@ -547,8 +558,12 @@ k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8= k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I= k8s.io/kube-aggregator v0.18.2 h1:mgsze91nZC27HeJi8bLRyhLINQznEUy4SOTpbOhsZEM= k8s.io/kube-aggregator v0.18.2/go.mod h1:ijq6FnNUoKinA6kKbkN6svdTacSoQVNtKqmQ1+XJEYQ= +k8s.io/kube-aggregator v0.18.6 h1:xGP3oe0tAWEYnGWTnDPjXiIItekrnwDA2O7w0WqvGoo= +k8s.io/kube-aggregator v0.18.6/go.mod h1:MKm8inLHdeiXQJCl6UdmgMosRrqJgyxO2obTXOkey/s= k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c h1:/KUFqjjqAcY4Us6luF5RDNZ16KJtb49HfR3ZHB9qYXM= k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E= +k8s.io/kube-openapi v0.0.0-20200410145947-61e04a5be9a6 h1:Oh3Mzx5pJ+yIumsAD0MOECPVeXsVot0UkiaCGVyfGQY= +k8s.io/kube-openapi v0.0.0-20200410145947-61e04a5be9a6/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E= k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89 h1:d4vVOjXm687F1iLSP2q3lyPPuyvTUt3aVoBpi2DqRsU= k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew= monis.app/go v0.0.0-20190702030534-c65526068664 h1:h9Gc+HM13BmZWiFFbSdWwlUUB/YYN5vMz0W8cN/7C1A= diff --git a/vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/secrets.go b/vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/secrets.go new file mode 100644 index 000000000..6db0273e0 --- /dev/null +++ b/vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/secrets.go @@ -0,0 +1,140 @@ +package secrets + +import ( + "context" + "encoding/base64" + "encoding/json" + "fmt" + "strconv" + "time" + + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" + apiserverconfigv1 "k8s.io/apiserver/pkg/apis/config/v1" + corev1client "k8s.io/client-go/kubernetes/typed/core/v1" + + "github.com/openshift/library-go/pkg/operator/encryption/state" +) + +// ToKeyState converts a key secret to a key state. +func ToKeyState(s *corev1.Secret) (state.KeyState, error) { + data := s.Data[EncryptionSecretKeyDataKey] + + keyID, validKeyID := state.NameToKeyID(s.Name) + if !validKeyID { + return state.KeyState{}, fmt.Errorf("secret %s/%s has an invalid name", s.Namespace, s.Name) + } + + key := state.KeyState{ + Key: apiserverconfigv1.Key{ + // we use keyID as the name to limit the length of the field as it is used as a prefix for every value in etcd + Name: strconv.FormatUint(keyID, 10), + Secret: base64.StdEncoding.EncodeToString(data), + }, + Backed: true, + } + + if v, ok := s.Annotations[EncryptionSecretMigratedTimestamp]; ok { + ts, err := time.Parse(time.RFC3339, v) + if err != nil { + return state.KeyState{}, fmt.Errorf("secret %s/%s has invalid %s annotation: %v", s.Namespace, s.Name, EncryptionSecretMigratedTimestamp, err) + } + key.Migrated.Timestamp = ts + } + + if v, ok := s.Annotations[EncryptionSecretMigratedResources]; ok && len(v) > 0 { + migrated := &MigratedGroupResources{} + if err := json.Unmarshal([]byte(v), migrated); err != nil { + return state.KeyState{}, fmt.Errorf("secret %s/%s has invalid %s annotation: %v", s.Namespace, s.Name, EncryptionSecretMigratedResources, err) + } + key.Migrated.Resources = migrated.Resources + } + + if v, ok := s.Annotations[encryptionSecretInternalReason]; ok && len(v) > 0 { + key.InternalReason = v + } + if v, ok := s.Annotations[encryptionSecretExternalReason]; ok && len(v) > 0 { + key.ExternalReason = v + } + + keyMode := state.Mode(s.Annotations[encryptionSecretMode]) + switch keyMode { + case state.AESCBC, state.SecretBox, state.Identity: + key.Mode = keyMode + default: + return state.KeyState{}, fmt.Errorf("secret %s/%s has invalid mode: %s", s.Namespace, s.Name, keyMode) + } + if keyMode != state.Identity && len(data) == 0 { + return state.KeyState{}, fmt.Errorf("secret %s/%s of mode %q must have non-empty key", s.Namespace, s.Name, keyMode) + } + + return key, nil +} + +// ToKeyState converts a key state to a key secret. +func FromKeyState(component string, ks state.KeyState) (*corev1.Secret, error) { + bs, err := base64.StdEncoding.DecodeString(ks.Key.Secret) + if err != nil { + return nil, fmt.Errorf("failed to decode key string") + } + + s := &corev1.Secret{ + ObjectMeta: metav1.ObjectMeta{ + Name: fmt.Sprintf("encryption-key-%s-%s", component, ks.Key.Name), + Namespace: "openshift-config-managed", + Labels: map[string]string{ + EncryptionKeySecretsLabel: component, + }, + Annotations: map[string]string{ + state.KubernetesDescriptionKey: state.KubernetesDescriptionScaryValue, + + encryptionSecretMode: string(ks.Mode), + encryptionSecretInternalReason: ks.InternalReason, + encryptionSecretExternalReason: ks.ExternalReason, + }, + Finalizers: []string{EncryptionSecretFinalizer}, + }, + Data: map[string][]byte{ + EncryptionSecretKeyDataKey: bs, + }, + Type: corev1.SecretTypeOpaque, + } + + if !ks.Migrated.Timestamp.IsZero() { + s.Annotations[EncryptionSecretMigratedTimestamp] = ks.Migrated.Timestamp.Format(time.RFC3339) + } + if len(ks.Migrated.Resources) > 0 { + migrated := MigratedGroupResources{Resources: ks.Migrated.Resources} + bs, err := json.Marshal(migrated) + if err != nil { + return nil, err + } + s.Annotations[EncryptionSecretMigratedResources] = string(bs) + } + + return s, nil +} + +// HasResource returns whether the given group resource is contained in the migrated group resource list. +func (m *MigratedGroupResources) HasResource(resource schema.GroupResource) bool { + for _, gr := range m.Resources { + if gr == resource { + return true + } + } + return false +} + +// ListKeySecrets returns the current key secrets from openshift-config-managed. +func ListKeySecrets(secretClient corev1client.SecretsGetter, encryptionSecretSelector metav1.ListOptions) ([]*corev1.Secret, error) { + encryptionSecretList, err := secretClient.Secrets("openshift-config-managed").List(context.TODO(), encryptionSecretSelector) + if err != nil { + return nil, err + } + var encryptionSecrets []*corev1.Secret + for i := range encryptionSecretList.Items { + encryptionSecrets = append(encryptionSecrets, &encryptionSecretList.Items[i]) + } + return encryptionSecrets, nil +} diff --git a/vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/types.go b/vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/types.go new file mode 100644 index 000000000..7161e4a12 --- /dev/null +++ b/vendor/github.com/openshift/library-go/pkg/operator/encryption/secrets/types.go @@ -0,0 +1,59 @@ +package secrets + +import ( + "k8s.io/apimachinery/pkg/runtime/schema" +) + +const ( + // This label is used to find secrets that build up the final encryption config. The names of the + // secrets are in format - (the uint is the keyID). + // For example, openshift-kube-apiserver-encryption-3. Note that other than the -3 postfix, the name of + // the secret is irrelevant since the label is used to find the secrets. Of course the key minting + // controller cares about the entire name since it needs to know when it has already created a secret for a given + // keyID meaning it cannot just use a random prefix. As such the name must include the data that is contained + // within the label. Thus the format used is -encryption-. This keeps everything distinct + // and fully deterministic. The keys are ordered by keyID where a smaller ID means an earlier key. + // This means that the latest secret (the one with the largest keyID) is the current desired write key. + EncryptionKeySecretsLabel = "encryption.apiserver.operator.openshift.io/component" + + // These annotations are used to mark the current observed state of a secret. + + // The time (in RFC3339 format) at which the migrated state observation occurred. The key minting + // controller parses this field to determine if enough time has passed and a new key should be created. + EncryptionSecretMigratedTimestamp = "encryption.apiserver.operator.openshift.io/migrated-timestamp" + // The list of resources that were migrated when encryptionSecretMigratedTimestamp was set. + // See the MigratedGroupResources struct below to understand the JSON encoding used. + EncryptionSecretMigratedResources = "encryption.apiserver.operator.openshift.io/migrated-resources" + + // encryptionSecretMode is the annotation that determines how the provider associated with a given key is + // configured. For example, a key could be used with AES-CBC or Secretbox. This allows for algorithm + // agility. When the default mode used by the key minting controller changes, it will force the creation + // of a new key under the new mode even if encryptionSecretMigrationInterval has not been reached. + encryptionSecretMode = "encryption.apiserver.operator.openshift.io/mode" + + // encryptionSecretInternalReason is the annotation that denotes why a particular key + // was created based on "internal" reasons (i.e. key minting controller decided a new + // key was needed for some reason X). It is tracked solely for the purposes of debugging. + encryptionSecretInternalReason = "encryption.apiserver.operator.openshift.io/internal-reason" + + // encryptionSecretExternalReason is the annotation that denotes why a particular key was created based on + // "external" reasons (i.e. force key rotation for some reason Y). It allows the key minting controller to + // determine if a new key should be created even if encryptionSecretMigrationInterval has not been reached. + encryptionSecretExternalReason = "encryption.apiserver.operator.openshift.io/external-reason" + + // In the data field of the secret API object, this (map) key is used to hold the actual encryption key + // (i.e. for AES-CBC mode the value associated with this map key is 32 bytes of random noise). + EncryptionSecretKeyDataKey = "encryption.apiserver.operator.openshift.io-key" + + // encryptionSecretFinalizer is a finalizer attached to all secrets generated + // by the encryption controllers. Its sole purpose is to prevent the accidental + // deletion of secrets by enforcing a two phase delete. + EncryptionSecretFinalizer = "encryption.apiserver.operator.openshift.io/deletion-protection" +) + +// MigratedGroupResources is the data structured stored in the +// encryption.apiserver.operator.openshift.io/migrated-resources +// of a key secret. +type MigratedGroupResources struct { + Resources []schema.GroupResource `json:"resources"` +} diff --git a/vendor/github.com/openshift/library-go/pkg/operator/encryption/state/helpers.go b/vendor/github.com/openshift/library-go/pkg/operator/encryption/state/helpers.go new file mode 100644 index 000000000..656aeafef --- /dev/null +++ b/vendor/github.com/openshift/library-go/pkg/operator/encryption/state/helpers.go @@ -0,0 +1,84 @@ +package state + +import ( + "fmt" + "sort" + "strconv" + "strings" + + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// MigratedFor returns whether all given resources are marked as migrated in the given key. +// It returns missing GRs and a reason if that's not the case. +func MigratedFor(grs []schema.GroupResource, km KeyState) (ok bool, missing []schema.GroupResource, reason string) { + var missingStrings []string + for _, gr := range grs { + found := false + for _, mgr := range km.Migrated.Resources { + if mgr == gr { + found = true + break + } + } + if !found { + missing = append(missing, gr) + missingStrings = append(missingStrings, gr.String()) + } + } + + if len(missing) > 0 { + return false, missing, fmt.Sprintf("key ID %s misses resource %s among migrated resources", km.Key.Name, strings.Join(missingStrings, ",")) + } + + return true, nil, "" +} + +// KeysWithPotentiallyPersistedDataAndNextReadKey returns the minimal, recent secrets which have migrated all given GRs. +func KeysWithPotentiallyPersistedDataAndNextReadKey(grs []schema.GroupResource, recentFirstSortedKeys []KeyState) []KeyState { + for i, k := range recentFirstSortedKeys { + if allMigrated, missing, _ := MigratedFor(grs, k); allMigrated { + if i+1 < len(recentFirstSortedKeys) { + return recentFirstSortedKeys[:i+2] + } else { + return recentFirstSortedKeys[:i+1] + } + } else { + // continue with keys we haven't found a migration key for yet + grs = missing + } + } + return recentFirstSortedKeys +} + +func SortRecentFirst(unsorted []KeyState) []KeyState { + ret := make([]KeyState, len(unsorted)) + copy(ret, unsorted) + sort.Slice(ret, func(i, j int) bool { + // it is fine to ignore the validKeyID bool here because we filtered out invalid secrets in the loop above + iKeyID, _ := NameToKeyID(ret[i].Key.Name) + jKeyID, _ := NameToKeyID(ret[j].Key.Name) + return iKeyID > jKeyID + }) + return ret +} + +func NameToKeyID(name string) (uint64, bool) { + lastIdx := strings.LastIndex(name, "-") + idString := name + if lastIdx >= 0 { + idString = name[lastIdx+1:] // this can never overflow since str[-1+1:] is + } + id, err := strconv.ParseUint(idString, 10, 0) + return id, err == nil +} + +func EqualKeyAndEqualID(s1, s2 *KeyState) bool { + if s1.Mode != s2.Mode || s1.Key.Secret != s2.Key.Secret { + return false + } + + id1, valid1 := NameToKeyID(s1.Key.Name) + id2, valid2 := NameToKeyID(s2.Key.Name) + return valid1 && valid2 && id1 == id2 +} diff --git a/vendor/github.com/openshift/library-go/pkg/operator/encryption/state/types.go b/vendor/github.com/openshift/library-go/pkg/operator/encryption/state/types.go new file mode 100644 index 000000000..9a7174e43 --- /dev/null +++ b/vendor/github.com/openshift/library-go/pkg/operator/encryption/state/types.go @@ -0,0 +1,69 @@ +package state + +import ( + "time" + + "k8s.io/apimachinery/pkg/runtime/schema" + apiserverconfigv1 "k8s.io/apiserver/pkg/apis/config/v1" +) + +// These annotations try to scare anyone away from editing the encryption secrets. It is trivial for +// an external actor to break the invariants of the state machine and render the cluster unrecoverable. +const ( + KubernetesDescriptionKey = "kubernetes.io/description" + KubernetesDescriptionScaryValue = `WARNING: DO NOT EDIT. +Altering of the encryption secrets will render you cluster inaccessible. +Catastrophic data loss can occur from the most minor changes.` +) + +// GroupResourceState represents, for a single group resource, the write and read keys in a +// format that can be directly translated to and from the on disk EncryptionConfiguration object. +type GroupResourceState struct { + // the write key of the group resource. + WriteKey KeyState + // all read keys of the group resource. Potentially includes the write key. + ReadKeys []KeyState +} + +func (k GroupResourceState) HasWriteKey() bool { + return len(k.WriteKey.Key.Name) > 0 && len(k.WriteKey.Key.Secret) > 0 +} + +type KeyState struct { + Key apiserverconfigv1.Key + Mode Mode + + // described whether it is backed by a secret. + Backed bool + Migrated MigrationState + // some controller logic caused this secret to be created by the key controller. + InternalReason string + // the user via unsupportConfigOverrides.encryption.reason triggered this key. + ExternalReason string +} + +type MigrationState struct { + // the timestamp fo the last migration + Timestamp time.Time + // the resources that were migrated at some point in time to this key. + Resources []schema.GroupResource +} + +// Mode is the value associated with the encryptionSecretMode annotation +type Mode string + +// The current set of modes that are supported along with the default Mode that is used. +// These values are encoded into the secret and thus must not be changed. +// Strings are used over iota because they are easier for a human to understand. +const ( + AESCBC Mode = "aescbc" // available from the first release, see defaultMode below + SecretBox Mode = "secretbox" // available from the first release, see defaultMode below + Identity Mode = "identity" // available from the first release, see defaultMode below + + // Changing this value requires caution to not break downgrades. + // Specifically, if some new Mode is released in version X, that new Mode cannot + // be used as the defaultMode until version X+1. Thus on a downgrade the operator + // from version X will still be able to honor the observed encryption state + // (and it will do a key rotation to force the use of the old defaultMode). + DefaultMode = Identity // we default to encryption being disabled for now +) diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go index bf125b62a..e7aaead8c 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types.go @@ -873,6 +873,9 @@ const ( // FieldManagerConflict is used to report when another client claims to manage this field, // It should only be returned for a request using server-side apply. CauseTypeFieldManagerConflict CauseType = "FieldManagerConflict" + // CauseTypeResourceVersionTooLarge is used to report that the requested resource version + // is newer than the data observed by the API server, so the request cannot be served. + CauseTypeResourceVersionTooLarge CauseType = "ResourceVersionTooLarge" ) // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object diff --git a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go index 2743793dd..fcd491f4c 100644 --- a/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go +++ b/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go @@ -178,7 +178,7 @@ func ValidateManagedFields(fieldsList []metav1.ManagedFieldsEntry, fldPath *fiel default: allErrs = append(allErrs, field.Invalid(fldPath.Child("operation"), fields.Operation, "must be `Apply` or `Update`")) } - if fields.FieldsType != "FieldsV1" { + if len(fields.FieldsType) > 0 && fields.FieldsType != "FieldsV1" { allErrs = append(allErrs, field.Invalid(fldPath.Child("fieldsType"), fields.FieldsType, "must be `FieldsV1`")) } } diff --git a/vendor/k8s.io/apimachinery/pkg/util/json/json.go b/vendor/k8s.io/apimachinery/pkg/util/json/json.go index 0e2e30175..204834883 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/json/json.go +++ b/vendor/k8s.io/apimachinery/pkg/util/json/json.go @@ -66,11 +66,36 @@ func Unmarshal(data []byte, v interface{}) error { // If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64 return convertSliceNumbers(*v, 0) + case *interface{}: + // Build a decoder from the given data + decoder := json.NewDecoder(bytes.NewBuffer(data)) + // Preserve numbers, rather than casting to float64 automatically + decoder.UseNumber() + // Run the decode + if err := decoder.Decode(v); err != nil { + return err + } + // If the decode succeeds, post-process the map to convert json.Number objects to int64 or float64 + return convertInterfaceNumbers(v, 0) + default: return json.Unmarshal(data, v) } } +func convertInterfaceNumbers(v *interface{}, depth int) error { + var err error + switch v2 := (*v).(type) { + case json.Number: + *v, err = convertNumber(v2) + case map[string]interface{}: + err = convertMapNumbers(v2, depth+1) + case []interface{}: + err = convertSliceNumbers(v2, depth+1) + } + return err +} + // convertMapNumbers traverses the map, converting any json.Number values to int64 or float64. // values which are map[string]interface{} or []interface{} are recursively visited func convertMapNumbers(m map[string]interface{}, depth int) error { diff --git a/vendor/k8s.io/apimachinery/pkg/util/net/http.go b/vendor/k8s.io/apimachinery/pkg/util/net/http.go index 7449cbb0a..7b64e6815 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/net/http.go +++ b/vendor/k8s.io/apimachinery/pkg/util/net/http.go @@ -446,7 +446,7 @@ redirectLoop: // Only follow redirects to the same host. Otherwise, propagate the redirect response back. if requireSameHostRedirects && location.Hostname() != originalLocation.Hostname() { - break redirectLoop + return nil, nil, fmt.Errorf("hostname mismatch: expected %s, found %s", originalLocation.Hostname(), location.Hostname()) } // Reset the connection. diff --git a/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go b/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go index 4cb0c122c..d759d912b 100644 --- a/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go +++ b/vendor/k8s.io/apimachinery/pkg/util/wait/wait.go @@ -286,8 +286,9 @@ func contextForChannel(parentCh <-chan struct{}) (context.Context, context.Cance } // BackoffManager manages backoff with a particular scheme based on its underlying implementation. It provides -// an interface to return a timer for backoff, and caller shall backoff until Timer.C returns. If the second Backoff() -// is called before the timer from the first Backoff() call finishes, the first timer will NOT be drained. +// an interface to return a timer for backoff, and caller shall backoff until Timer.C() drains. If the second Backoff() +// is called before the timer from the first Backoff() call finishes, the first timer will NOT be drained and result in +// undetermined behavior. // The BackoffManager is supposed to be called in a single-threaded environment. type BackoffManager interface { Backoff() clock.Timer @@ -317,7 +318,7 @@ func NewExponentialBackoffManager(initBackoff, maxBackoff, resetDuration time.Du Steps: math.MaxInt32, Cap: maxBackoff, }, - backoffTimer: c.NewTimer(0), + backoffTimer: nil, initialBackoff: initBackoff, lastBackoffStart: c.Now(), backoffResetDuration: resetDuration, @@ -334,9 +335,14 @@ func (b *exponentialBackoffManagerImpl) getNextBackoff() time.Duration { return b.backoff.Step() } -// Backoff implements BackoffManager.Backoff, it returns a timer so caller can block on the timer for backoff. +// Backoff implements BackoffManager.Backoff, it returns a timer so caller can block on the timer for exponential backoff. +// The returned timer must be drained before calling Backoff() the second time func (b *exponentialBackoffManagerImpl) Backoff() clock.Timer { - b.backoffTimer.Reset(b.getNextBackoff()) + if b.backoffTimer == nil { + b.backoffTimer = b.clock.NewTimer(b.getNextBackoff()) + } else { + b.backoffTimer.Reset(b.getNextBackoff()) + } return b.backoffTimer } @@ -354,7 +360,7 @@ func NewJitteredBackoffManager(duration time.Duration, jitter float64, c clock.C clock: c, duration: duration, jitter: jitter, - backoffTimer: c.NewTimer(0), + backoffTimer: nil, } } @@ -366,8 +372,15 @@ func (j *jitteredBackoffManagerImpl) getNextBackoff() time.Duration { return jitteredPeriod } +// Backoff implements BackoffManager.Backoff, it returns a timer so caller can block on the timer for jittered backoff. +// The returned timer must be drained before calling Backoff() the second time func (j *jitteredBackoffManagerImpl) Backoff() clock.Timer { - j.backoffTimer.Reset(j.getNextBackoff()) + backoff := j.getNextBackoff() + if j.backoffTimer == nil { + j.backoffTimer = j.clock.NewTimer(backoff) + } else { + j.backoffTimer.Reset(backoff) + } return j.backoffTimer } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go index f97cbaa2c..653c1ff82 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/create.go @@ -156,10 +156,7 @@ func createHandler(r rest.NamedCreater, scope *RequestScope, admit admission.Int if err != nil { return nil, fmt.Errorf("failed to create new object (Create for %v): %v", scope.Kind, err) } - obj, err = scope.FieldManager.Update(liveObj, obj, managerOrUserAgent(options.FieldManager, req.UserAgent())) - if err != nil { - return nil, fmt.Errorf("failed to update object (Create for %v) managed fields: %v", scope.Kind, err) - } + obj = scope.FieldManager.UpdateNoErrors(liveObj, obj, managerOrUserAgent(options.FieldManager, req.UserAgent())) } if mutatingAdmission, ok := admit.(admission.MutationInterface); ok && mutatingAdmission.Handles(admission.Create) { if err := mutatingAdmission.Admit(ctx, admissionAttributes, scope); err != nil { diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go index bd47efe22..69d8920aa 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go @@ -18,12 +18,15 @@ package fieldmanager import ( "fmt" + "reflect" + "time" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal" + "k8s.io/klog" openapiproto "k8s.io/kube-openapi/pkg/util/proto" "sigs.k8s.io/structured-merge-diff/v3/fieldpath" ) @@ -37,6 +40,8 @@ const DefaultMaxUpdateManagers int = 10 // starts being tracked from the object's creation, instead of from the first time the object is applied to. const DefaultTrackOnCreateProbability float32 = 1 +var atMostEverySecond = internal.NewAtMostEvery(time.Second) + // Managed groups a fieldpath.ManagedFields together with the timestamps associated with each operation. type Managed interface { // Fields gets the fieldpath.ManagedFields. @@ -107,20 +112,26 @@ func newDefaultFieldManager(f Manager, objectCreater runtime.ObjectCreater, kind func (f *FieldManager) Update(liveObj, newObj runtime.Object, manager string) (object runtime.Object, err error) { // If the object doesn't have metadata, we should just return without trying to // set the managedFields at all, so creates/updates/patches will work normally. - if _, err = meta.Accessor(newObj); err != nil { + newAccessor, err := meta.Accessor(newObj) + if err != nil { return newObj, nil } // First try to decode the managed fields provided in the update, // This is necessary to allow directly updating managed fields. var managed Managed - if managed, err = internal.DecodeObjectManagedFields(newObj); err != nil || len(managed.Fields()) == 0 { + if isResetManagedFields(newAccessor.GetManagedFields()) { + managed = internal.NewEmptyManaged() + } else if managed, err = internal.DecodeObjectManagedFields(newAccessor.GetManagedFields()); err != nil || len(managed.Fields()) == 0 { + liveAccessor, err := meta.Accessor(liveObj) + if err != nil { + return newObj, nil + } // If the managed field is empty or we failed to decode it, // let's try the live object. This is to prevent clients who // don't understand managedFields from deleting it accidentally. - managed, err = internal.DecodeObjectManagedFields(liveObj) - if err != nil { - return nil, fmt.Errorf("failed to decode managed fields: %v", err) + if managed, err = internal.DecodeObjectManagedFields(liveAccessor.GetManagedFields()); err != nil { + managed = internal.NewEmptyManaged() } } @@ -138,17 +149,52 @@ func (f *FieldManager) Update(liveObj, newObj runtime.Object, manager string) (o return object, nil } +// UpdateNoErrors is the same as Update, but it will not return +// errors. If an error happens, the object is returned with +// managedFields cleared. +func (f *FieldManager) UpdateNoErrors(liveObj, newObj runtime.Object, manager string) runtime.Object { + obj, err := f.Update(liveObj, newObj, manager) + if err != nil { + atMostEverySecond.Do(func() { + klog.Errorf("[SHOULD NOT HAPPEN] failed to update managedFields for %v: %v", + newObj.GetObjectKind().GroupVersionKind(), + err) + }) + // Explicitly remove managedFields on failure, so that + // we can't have garbage in it. + internal.RemoveObjectManagedFields(newObj) + return newObj + } + return obj +} + +// Returns true if the managedFields indicate that the user is trying to +// reset the managedFields, i.e. if the list is non-nil but empty, or if +// the list has one empty item. +func isResetManagedFields(managedFields []metav1.ManagedFieldsEntry) bool { + if len(managedFields) == 0 { + return managedFields != nil + } + + if len(managedFields) == 1 { + return reflect.DeepEqual(managedFields[0], metav1.ManagedFieldsEntry{}) + } + + return false +} + // Apply is used when server-side apply is called, as it merges the // object and updates the managed fields. func (f *FieldManager) Apply(liveObj, appliedObj runtime.Object, manager string, force bool) (object runtime.Object, err error) { // If the object doesn't have metadata, apply isn't allowed. - if _, err = meta.Accessor(liveObj); err != nil { + accessor, err := meta.Accessor(liveObj) + if err != nil { return nil, fmt.Errorf("couldn't get accessor: %v", err) } // Decode the managed fields in the live object, since it isn't allowed in the patch. - var managed Managed - if managed, err = internal.DecodeObjectManagedFields(liveObj); err != nil { + managed, err := internal.DecodeObjectManagedFields(accessor.GetManagedFields()) + if err != nil { return nil, fmt.Errorf("failed to decode managed fields: %v", err) } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/managedfields.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/managedfields.go index 4778fa792..c5434b101 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/managedfields.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal/managedfields.go @@ -53,6 +53,11 @@ func (m *managedStruct) Times() map[string]*metav1.Time { return m.times } +// NewEmptyManaged creates an empty ManagedInterface. +func NewEmptyManaged() ManagedInterface { + return NewManaged(fieldpath.ManagedFields{}, map[string]*metav1.Time{}) +} + // NewManaged creates a ManagedInterface from a fieldpath.ManagedFields and the timestamps associated with each operation. func NewManaged(f fieldpath.ManagedFields, t map[string]*metav1.Time) ManagedInterface { return &managedStruct{ @@ -73,16 +78,8 @@ func RemoveObjectManagedFields(obj runtime.Object) { } // DecodeObjectManagedFields extracts and converts the objects ManagedFields into a fieldpath.ManagedFields. -func DecodeObjectManagedFields(from runtime.Object) (ManagedInterface, error) { - if from == nil { - return &managedStruct{}, nil - } - accessor, err := meta.Accessor(from) - if err != nil { - panic(fmt.Sprintf("couldn't get accessor: %v", err)) - } - - managed, err := decodeManagedFields(accessor.GetManagedFields()) +func DecodeObjectManagedFields(from []metav1.ManagedFieldsEntry) (ManagedInterface, error) { + managed, err := decodeManagedFields(from) if err != nil { return nil, fmt.Errorf("failed to convert managed fields from API: %v", err) } @@ -110,7 +107,16 @@ func EncodeObjectManagedFields(obj runtime.Object, managed ManagedInterface) err func decodeManagedFields(encodedManagedFields []metav1.ManagedFieldsEntry) (managed managedStruct, err error) { managed.fields = make(fieldpath.ManagedFields, len(encodedManagedFields)) managed.times = make(map[string]*metav1.Time, len(encodedManagedFields)) - for _, encodedVersionedSet := range encodedManagedFields { + + for i, encodedVersionedSet := range encodedManagedFields { + switch encodedVersionedSet.FieldsType { + case "FieldsV1": + // Valid case. + case "": + return managedStruct{}, fmt.Errorf("missing fieldsType in managed fields entry %d", i) + default: + return managedStruct{}, fmt.Errorf("invalid fieldsType %q in managed fields entry %d", encodedVersionedSet.FieldsType, i) + } manager, err := BuildManagerIdentifier(&encodedVersionedSet) if err != nil { return managedStruct{}, fmt.Errorf("error decoding manager from %v: %v", encodedVersionedSet, err) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go index 32116a94d..3ec16a838 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/structuredmerge.go @@ -18,14 +18,12 @@ package fieldmanager import ( "fmt" - "time" "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal" - "k8s.io/klog" openapiproto "k8s.io/kube-openapi/pkg/util/proto" "sigs.k8s.io/structured-merge-diff/v3/fieldpath" "sigs.k8s.io/structured-merge-diff/v3/merge" @@ -41,7 +39,6 @@ type structuredMergeManager struct { } var _ Manager = &structuredMergeManager{} -var atMostEverySecond = internal.NewAtMostEvery(time.Second) // NewStructuredMergeManager creates a new Manager that merges apply requests // and update managed fields for other types of requests. @@ -98,19 +95,11 @@ func (f *structuredMergeManager) Update(liveObj, newObj runtime.Object, managed } newObjTyped, err := f.typeConverter.ObjectToTyped(newObjVersioned) if err != nil { - // Return newObj and just by-pass fields update. This really shouldn't happen. - atMostEverySecond.Do(func() { - klog.Errorf("[SHOULD NOT HAPPEN] failed to create typed new object of type %v: %v", newObjVersioned.GetObjectKind().GroupVersionKind(), err) - }) - return newObj, managed, nil + return nil, nil, fmt.Errorf("failed to convert new object (%v) to smd typed: %v", newObjVersioned.GetObjectKind().GroupVersionKind(), err) } liveObjTyped, err := f.typeConverter.ObjectToTyped(liveObjVersioned) if err != nil { - // Return newObj and just by-pass fields update. This really shouldn't happen. - atMostEverySecond.Do(func() { - klog.Errorf("[SHOULD NOT HAPPEN] failed to create typed live object of type %v: %v", liveObjVersioned.GetObjectKind().GroupVersionKind(), err) - }) - return newObj, managed, nil + return nil, nil, fmt.Errorf("failed to convert live object (%v) to smd typed: %v", liveObjVersioned.GetObjectKind().GroupVersionKind(), err) } apiVersion := fieldpath.APIVersion(f.groupVersion.String()) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go index e9d110017..c295d0aa6 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/patch.go @@ -323,9 +323,7 @@ func (p *jsonPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (r } if p.fieldManager != nil { - if objToUpdate, err = p.fieldManager.Update(currentObject, objToUpdate, managerOrUserAgent(p.options.FieldManager, p.userAgent)); err != nil { - return nil, fmt.Errorf("failed to update object (json PATCH for %v) managed fields: %v", p.kind, err) - } + objToUpdate = p.fieldManager.UpdateNoErrors(currentObject, objToUpdate, managerOrUserAgent(p.options.FieldManager, p.userAgent)) } return objToUpdate, nil } @@ -408,9 +406,7 @@ func (p *smpPatcher) applyPatchToCurrentObject(currentObject runtime.Object) (ru } if p.fieldManager != nil { - if newObj, err = p.fieldManager.Update(currentObject, newObj, managerOrUserAgent(p.options.FieldManager, p.userAgent)); err != nil { - return nil, fmt.Errorf("failed to update object (smp PATCH for %v) managed fields: %v", p.kind, err) - } + newObj = p.fieldManager.UpdateNoErrors(currentObject, newObj, managerOrUserAgent(p.options.FieldManager, p.userAgent)) } return newObj, nil } diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go index c58fe9d57..91b909ea6 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/handlers/update.go @@ -131,11 +131,7 @@ func UpdateResource(r rest.Updater, scope *RequestScope, admit admission.Interfa if scope.FieldManager != nil { transformers = append(transformers, func(_ context.Context, newObj, liveObj runtime.Object) (runtime.Object, error) { if shouldUpdateManagedFields { - obj, err := scope.FieldManager.Update(liveObj, newObj, managerOrUserAgent(options.FieldManager, req.UserAgent())) - if err != nil { - return nil, fmt.Errorf("failed to update object (Update for %v) managed fields: %v", scope.Kind, err) - } - return obj, nil + return scope.FieldManager.UpdateNoErrors(liveObj, newObj, managerOrUserAgent(options.FieldManager, req.UserAgent())), nil } return newObj, nil }) diff --git a/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go b/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go index c79efdef4..6f1a836e3 100644 --- a/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go +++ b/vendor/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go @@ -28,7 +28,6 @@ import ( "time" restful "github.com/emicklei/go-restful" - "k8s.io/apimachinery/pkg/apis/meta/v1/validation" "k8s.io/apimachinery/pkg/types" utilsets "k8s.io/apimachinery/pkg/util/sets" @@ -48,6 +47,8 @@ type resettableCollector interface { const ( APIServerComponent string = "apiserver" + OtherContentType string = "other" + OtherRequestMethod string = "other" ) /* @@ -172,6 +173,37 @@ var ( currentInflightRequests, requestTerminationsTotal, } + + // these are the known (e.g. whitelisted/known) content types which we will report for + // request metrics. Any other RFC compliant content types will be aggregated under 'unknown' + knownMetricContentTypes = utilsets.NewString( + "application/apply-patch+yaml", + "application/json", + "application/json-patch+json", + "application/merge-patch+json", + "application/strategic-merge-patch+json", + "application/vnd.kubernetes.protobuf", + "application/vnd.kubernetes.protobuf;stream=watch", + "application/yaml", + "text/plain", + "text/plain;charset=utf-8") + // these are the valid request methods which we report in our metrics. Any other request methods + // will be aggregated under 'unknown' + validRequestMethods = utilsets.NewString( + "APPLY", + "CONNECT", + "CREATE", + "DELETE", + "DELETECOLLECTION", + "GET", + "LIST", + "PATCH", + "POST", + "PROXY", + "PUT", + "UPDATE", + "WATCH", + "WATCHLIST") ) const ( @@ -219,6 +251,10 @@ func RecordRequestTermination(req *http.Request, requestInfo *request.RequestInf // translated to RequestInfo). // However, we need to tweak it e.g. to differentiate GET from LIST. verb := canonicalVerb(strings.ToUpper(req.Method), scope) + // set verbs to a bounded set of known and expected verbs + if !validRequestMethods.Has(verb) { + verb = OtherRequestMethod + } if requestInfo.IsResourceRequest { requestTerminationsTotal.WithLabelValues(cleanVerb(verb, req), requestInfo.APIGroup, requestInfo.APIVersion, requestInfo.Resource, requestInfo.Subresource, scope, component, codeToString(code)).Inc() } else { @@ -256,7 +292,8 @@ func MonitorRequest(req *http.Request, verb, group, version, resource, subresour reportedVerb := cleanVerb(verb, req) dryRun := cleanDryRun(req.URL) elapsedSeconds := elapsed.Seconds() - requestCounter.WithLabelValues(reportedVerb, dryRun, group, version, resource, subresource, scope, component, contentType, codeToString(httpCode)).Inc() + cleanContentType := cleanContentType(contentType) + requestCounter.WithLabelValues(reportedVerb, dryRun, group, version, resource, subresource, scope, component, cleanContentType, codeToString(httpCode)).Inc() requestLatencies.WithLabelValues(reportedVerb, dryRun, group, version, resource, subresource, scope, component).Observe(elapsedSeconds) // We are only interested in response sizes of read requests. if verb == "GET" || verb == "LIST" { @@ -311,6 +348,19 @@ func InstrumentHandlerFunc(verb, group, version, resource, subresource, scope, c } } +// cleanContentType binds the contentType (for metrics related purposes) to a +// bounded set of known/expected content-types. +func cleanContentType(contentType string) string { + normalizedContentType := strings.ToLower(contentType) + if strings.HasSuffix(contentType, " stream=watch") || strings.HasSuffix(contentType, " charset=utf-8") { + normalizedContentType = strings.ReplaceAll(contentType, " ", "") + } + if knownMetricContentTypes.Has(normalizedContentType) { + return normalizedContentType + } + return OtherContentType +} + // CleanScope returns the scope of the request. func CleanScope(requestInfo *request.RequestInfo) string { if requestInfo.Namespace != "" { @@ -355,7 +405,10 @@ func cleanVerb(verb string, request *http.Request) string { if verb == "PATCH" && request.Header.Get("Content-Type") == string(types.ApplyPatchType) && utilfeature.DefaultFeatureGate.Enabled(features.ServerSideApply) { reportedVerb = "APPLY" } - return reportedVerb + if validRequestMethods.Has(reportedVerb) { + return reportedVerb + } + return OtherRequestMethod } func cleanDryRun(u *url.URL) string { diff --git a/vendor/k8s.io/apiserver/pkg/server/config.go b/vendor/k8s.io/apiserver/pkg/server/config.go index db5368bf0..00efd0cc9 100644 --- a/vendor/k8s.io/apiserver/pkg/server/config.go +++ b/vendor/k8s.io/apiserver/pkg/server/config.go @@ -606,13 +606,20 @@ func (c completedConfig) New(name string, delegationTarget DelegationTarget) (*G } genericApiServerHookName := "generic-apiserver-start-informers" - if c.SharedInformerFactory != nil && !s.isPostStartHookRegistered(genericApiServerHookName) { - err := s.AddPostStartHook(genericApiServerHookName, func(context PostStartHookContext) error { - c.SharedInformerFactory.Start(context.StopCh) - return nil - }) - if err != nil { - return nil, err + if c.SharedInformerFactory != nil { + if !s.isPostStartHookRegistered(genericApiServerHookName) { + err := s.AddPostStartHook(genericApiServerHookName, func(context PostStartHookContext) error { + c.SharedInformerFactory.Start(context.StopCh) + return nil + }) + if err != nil { + return nil, err + } + // TODO: Once we get rid of /healthz consider changing this to post-start-hook. + err = s.addReadyzChecks(healthz.NewInformerSyncHealthz(c.SharedInformerFactory)) + if err != nil { + return nil, err + } } } @@ -680,6 +687,7 @@ func DefaultBuildHandlerChain(apiHandler http.Handler, c *Config) http.Handler { if c.SecureServing != nil && !c.SecureServing.DisableHTTP2 && c.GoawayChance > 0 { handler = genericfilters.WithProbabilisticGoaway(handler, c.GoawayChance) } + handler = genericapifilters.WithCacheControl(handler) handler = genericfilters.WithPanicRecovery(handler) return handler } diff --git a/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go b/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go index b5ca8afb2..75dd88741 100644 --- a/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go +++ b/vendor/k8s.io/apiserver/pkg/server/healthz/healthz.go @@ -29,6 +29,7 @@ import ( "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apiserver/pkg/endpoints/metrics" "k8s.io/apiserver/pkg/server/httplog" + "k8s.io/client-go/informers" "k8s.io/klog" ) @@ -81,6 +82,39 @@ func (l *log) Check(_ *http.Request) error { return fmt.Errorf("logging blocked") } +type informerSync struct { + sharedInformerFactory informers.SharedInformerFactory +} + +var _ HealthChecker = &informerSync{} + +// NewInformerSyncHealthz returns a new HealthChecker that will pass only if all informers in the given sharedInformerFactory sync. +func NewInformerSyncHealthz(sharedInformerFactory informers.SharedInformerFactory) HealthChecker { + return &informerSync{ + sharedInformerFactory: sharedInformerFactory, + } +} + +func (i *informerSync) Name() string { + return "informer-sync" +} + +func (i *informerSync) Check(_ *http.Request) error { + stopCh := make(chan struct{}) + // Close stopCh to force checking if informers are synced now. + close(stopCh) + + var informersByStarted map[bool][]string + for informerType, started := range i.sharedInformerFactory.WaitForCacheSync(stopCh) { + informersByStarted[started] = append(informersByStarted[started], informerType.String()) + } + + if notStarted := informersByStarted[false]; len(notStarted) > 0 { + return fmt.Errorf("%d informers not started yet: %v", len(notStarted), notStarted) + } + return nil +} + // NamedCheck returns a healthz checker for the given name and function. func NamedCheck(name string, check func(r *http.Request) error) HealthChecker { return &healthzCheck{name, check} diff --git a/vendor/k8s.io/apiserver/pkg/storage/errors.go b/vendor/k8s.io/apiserver/pkg/storage/errors.go index 3acee4598..9c72d59fb 100644 --- a/vendor/k8s.io/apiserver/pkg/storage/errors.go +++ b/vendor/k8s.io/apiserver/pkg/storage/errors.go @@ -177,7 +177,12 @@ var tooLargeResourceVersionCauseMsg = "Too large resource version" // a minimum resource version that is larger than the largest currently available resource version for a requested resource. func NewTooLargeResourceVersionError(minimumResourceVersion, currentRevision uint64, retrySeconds int) error { err := errors.NewTimeoutError(fmt.Sprintf("Too large resource version: %d, current: %d", minimumResourceVersion, currentRevision), retrySeconds) - err.ErrStatus.Details.Causes = []metav1.StatusCause{{Message: tooLargeResourceVersionCauseMsg}} + err.ErrStatus.Details.Causes = []metav1.StatusCause{ + { + Type: metav1.CauseTypeResourceVersionTooLarge, + Message: tooLargeResourceVersionCauseMsg, + }, + } return err } @@ -186,15 +191,5 @@ func IsTooLargeResourceVersion(err error) bool { if !errors.IsTimeout(err) { return false } - switch t := err.(type) { - case errors.APIStatus: - if d := t.Status().Details; d != nil { - for _, cause := range d.Causes { - if cause.Message == tooLargeResourceVersionCauseMsg { - return true - } - } - } - } - return false + return errors.HasStatusCause(err, metav1.CauseTypeResourceVersionTooLarge) } diff --git a/vendor/k8s.io/client-go/tools/cache/reflector.go b/vendor/k8s.io/client-go/tools/cache/reflector.go index 99a7b284b..58f871f51 100644 --- a/vendor/k8s.io/client-go/tools/cache/reflector.go +++ b/vendor/k8s.io/client-go/tools/cache/reflector.go @@ -82,9 +82,9 @@ type Reflector struct { // observed when doing a sync with the underlying store // it is thread safe, but not synchronized with the underlying store lastSyncResourceVersion string - // isLastSyncResourceVersionGone is true if the previous list or watch request with lastSyncResourceVersion - // failed with an HTTP 410 (Gone) status code. - isLastSyncResourceVersionGone bool + // isLastSyncResourceVersionUnavailable is true if the previous list or watch request with + // lastSyncResourceVersion failed with an "expired" or "too large resource version" error. + isLastSyncResourceVersionUnavailable bool // lastSyncResourceVersionMutex guards read/write access to lastSyncResourceVersion lastSyncResourceVersionMutex sync.RWMutex // WatchListPageSize is the requested chunk size of initial and resync watch lists. @@ -256,13 +256,14 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { } list, paginatedResult, err = pager.List(context.Background(), options) - if isExpiredError(err) { - r.setIsLastSyncResourceVersionExpired(true) - // Retry immediately if the resource version used to list is expired. + if isExpiredError(err) || isTooLargeResourceVersionError(err) { + r.setIsLastSyncResourceVersionUnavailable(true) + // Retry immediately if the resource version used to list is unavailable. // The pager already falls back to full list if paginated list calls fail due to an "Expired" error on - // continuation pages, but the pager might not be enabled, or the full list might fail because the - // resource version it is listing at is expired, so we need to fallback to resourceVersion="" in all - // to recover and ensure the reflector makes forward progress. + // continuation pages, but the pager might not be enabled, the full list might fail because the + // resource version it is listing at is expired or the cache may not yet be synced to the provided + // resource version. So we need to fallback to resourceVersion="" in all to recover and ensure + // the reflector makes forward progress. list, paginatedResult, err = pager.List(context.Background(), metav1.ListOptions{ResourceVersion: r.relistResourceVersion()}) } close(listCh) @@ -292,7 +293,7 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { r.paginatedResult = true } - r.setIsLastSyncResourceVersionExpired(false) // list was successful + r.setIsLastSyncResourceVersionUnavailable(false) // list was successful initTrace.Step("Objects listed") listMetaInterface, err := meta.ListAccessor(list) if err != nil { @@ -396,7 +397,7 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error { if err != errorStopRequested { switch { case isExpiredError(err): - // Don't set LastSyncResourceVersionExpired - LIST call with ResourceVersion=RV already + // Don't set LastSyncResourceVersionUnavailable - LIST call with ResourceVersion=RV already // has a semantic that it returns data at least as fresh as provided RV. // So first try to LIST with setting RV to resource version of last observed object. klog.V(4).Infof("%s: watch of %v closed with: %v", r.name, r.expectedTypeName, err) @@ -519,9 +520,9 @@ func (r *Reflector) relistResourceVersion() string { r.lastSyncResourceVersionMutex.RLock() defer r.lastSyncResourceVersionMutex.RUnlock() - if r.isLastSyncResourceVersionGone { + if r.isLastSyncResourceVersionUnavailable { // Since this reflector makes paginated list requests, and all paginated list requests skip the watch cache - // if the lastSyncResourceVersion is expired, we set ResourceVersion="" and list again to re-establish reflector + // if the lastSyncResourceVersion is unavailable, we set ResourceVersion="" and list again to re-establish reflector // to the latest available ResourceVersion, using a consistent read from etcd. return "" } @@ -533,12 +534,12 @@ func (r *Reflector) relistResourceVersion() string { return r.lastSyncResourceVersion } -// setIsLastSyncResourceVersionExpired sets if the last list or watch request with lastSyncResourceVersion returned a -// expired error: HTTP 410 (Gone) Status Code. -func (r *Reflector) setIsLastSyncResourceVersionExpired(isExpired bool) { +// setIsLastSyncResourceVersionUnavailable sets if the last list or watch request with lastSyncResourceVersion returned +// "expired" or "too large resource version" error. +func (r *Reflector) setIsLastSyncResourceVersionUnavailable(isUnavailable bool) { r.lastSyncResourceVersionMutex.Lock() defer r.lastSyncResourceVersionMutex.Unlock() - r.isLastSyncResourceVersionGone = isExpired + r.isLastSyncResourceVersionUnavailable = isUnavailable } func isExpiredError(err error) bool { @@ -548,3 +549,7 @@ func isExpiredError(err error) bool { // check when we fully drop support for Kubernetes 1.17 servers from reflectors. return apierrors.IsResourceExpired(err) || apierrors.IsGone(err) } + +func isTooLargeResourceVersionError(err error) bool { + return apierrors.HasStatusCause(err, metav1.CauseTypeResourceVersionTooLarge) +} diff --git a/vendor/k8s.io/client-go/tools/clientcmd/client_config.go b/vendor/k8s.io/client-go/tools/clientcmd/client_config.go index 5096f51d2..a9806384a 100644 --- a/vendor/k8s.io/client-go/tools/clientcmd/client_config.go +++ b/vendor/k8s.io/client-go/tools/clientcmd/client_config.go @@ -35,7 +35,7 @@ import ( var ( // ClusterDefaults has the same behavior as the old EnvVar and DefaultCluster fields // DEPRECATED will be replaced - ClusterDefaults = clientcmdapi.Cluster{Server: os.Getenv("KUBERNETES_MASTER")} + ClusterDefaults = clientcmdapi.Cluster{Server: getDefaultServer()} // DefaultClientConfig represents the legacy behavior of this package for defaulting // DEPRECATED will be replace DefaultClientConfig = DirectClientConfig{*clientcmdapi.NewConfig(), "", &ConfigOverrides{ @@ -43,6 +43,15 @@ var ( }, nil, NewDefaultClientConfigLoadingRules(), promptedCredentials{}} ) +// getDefaultServer returns a default setting for DefaultClientConfig +// DEPRECATED +func getDefaultServer() string { + if server := os.Getenv("KUBERNETES_MASTER"); len(server) > 0 { + return server + } + return "http://localhost:8080" +} + // ClientConfig is used to make it easy to get an api server client type ClientConfig interface { // RawConfig returns the merged result of all overrides diff --git a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go index 608f75249..6390b4ef5 100644 --- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go +++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go @@ -88,6 +88,9 @@ func (cml *ConfigMapLock) Update(ctx context.Context, ler LeaderElectionRecord) if err != nil { return err } + if cml.cm.Annotations == nil { + cml.cm.Annotations = make(map[string]string) + } cml.cm.Annotations[LeaderElectionRecordAnnotationKey] = string(recordBytes) cml.cm, err = cml.Client.ConfigMaps(cml.ConfigMapMeta.Namespace).Update(ctx, cml.cm, metav1.UpdateOptions{}) return err diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go new file mode 100644 index 000000000..0680b9de0 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go @@ -0,0 +1,111 @@ +/* +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 client-gen. DO NOT EDIT. + +package clientset + +import ( + "fmt" + + discovery "k8s.io/client-go/discovery" + rest "k8s.io/client-go/rest" + flowcontrol "k8s.io/client-go/util/flowcontrol" + apiregistrationv1 "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1" + apiregistrationv1beta1 "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1" +) + +type Interface interface { + Discovery() discovery.DiscoveryInterface + ApiregistrationV1beta1() apiregistrationv1beta1.ApiregistrationV1beta1Interface + ApiregistrationV1() apiregistrationv1.ApiregistrationV1Interface +} + +// Clientset contains the clients for groups. Each group has exactly one +// version included in a Clientset. +type Clientset struct { + *discovery.DiscoveryClient + apiregistrationV1beta1 *apiregistrationv1beta1.ApiregistrationV1beta1Client + apiregistrationV1 *apiregistrationv1.ApiregistrationV1Client +} + +// ApiregistrationV1beta1 retrieves the ApiregistrationV1beta1Client +func (c *Clientset) ApiregistrationV1beta1() apiregistrationv1beta1.ApiregistrationV1beta1Interface { + return c.apiregistrationV1beta1 +} + +// ApiregistrationV1 retrieves the ApiregistrationV1Client +func (c *Clientset) ApiregistrationV1() apiregistrationv1.ApiregistrationV1Interface { + return c.apiregistrationV1 +} + +// Discovery retrieves the DiscoveryClient +func (c *Clientset) Discovery() discovery.DiscoveryInterface { + if c == nil { + return nil + } + return c.DiscoveryClient +} + +// NewForConfig creates a new Clientset for the given config. +// If config's RateLimiter is not set and QPS and Burst are acceptable, +// NewForConfig will generate a rate-limiter in configShallowCopy. +func NewForConfig(c *rest.Config) (*Clientset, error) { + configShallowCopy := *c + if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { + if configShallowCopy.Burst <= 0 { + return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0") + } + configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) + } + var cs Clientset + var err error + cs.apiregistrationV1beta1, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy) + if err != nil { + return nil, err + } + cs.apiregistrationV1, err = apiregistrationv1.NewForConfig(&configShallowCopy) + if err != nil { + return nil, err + } + + cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy) + if err != nil { + return nil, err + } + return &cs, nil +} + +// NewForConfigOrDie creates a new Clientset for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *Clientset { + var cs Clientset + cs.apiregistrationV1beta1 = apiregistrationv1beta1.NewForConfigOrDie(c) + cs.apiregistrationV1 = apiregistrationv1.NewForConfigOrDie(c) + + cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) + return &cs +} + +// New creates a new Clientset for the given RESTClient. +func New(c rest.Interface) *Clientset { + var cs Clientset + cs.apiregistrationV1beta1 = apiregistrationv1beta1.New(c) + cs.apiregistrationV1 = apiregistrationv1.New(c) + + cs.DiscoveryClient = discovery.NewDiscoveryClient(c) + return &cs +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/doc.go b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/doc.go new file mode 100644 index 000000000..ee865e56d --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/doc.go @@ -0,0 +1,20 @@ +/* +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 client-gen. DO NOT EDIT. + +// This package has the automatically generated clientset. +package clientset diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiregistration_client.go b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiregistration_client.go new file mode 100644 index 000000000..e7a9aa507 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiregistration_client.go @@ -0,0 +1,89 @@ +/* +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 client-gen. DO NOT EDIT. + +package v1beta1 + +import ( + rest "k8s.io/client-go/rest" + v1beta1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1" + "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme" +) + +type ApiregistrationV1beta1Interface interface { + RESTClient() rest.Interface + APIServicesGetter +} + +// ApiregistrationV1beta1Client is used to interact with features provided by the apiregistration.k8s.io group. +type ApiregistrationV1beta1Client struct { + restClient rest.Interface +} + +func (c *ApiregistrationV1beta1Client) APIServices() APIServiceInterface { + return newAPIServices(c) +} + +// NewForConfig creates a new ApiregistrationV1beta1Client for the given config. +func NewForConfig(c *rest.Config) (*ApiregistrationV1beta1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientFor(&config) + if err != nil { + return nil, err + } + return &ApiregistrationV1beta1Client{client}, nil +} + +// NewForConfigOrDie creates a new ApiregistrationV1beta1Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *ApiregistrationV1beta1Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new ApiregistrationV1beta1Client for the given RESTClient. +func New(c rest.Interface) *ApiregistrationV1beta1Client { + return &ApiregistrationV1beta1Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := v1beta1.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = scheme.Codecs.WithoutConversion() + + if config.UserAgent == "" { + config.UserAgent = rest.DefaultKubernetesUserAgent() + } + + return nil +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *ApiregistrationV1beta1Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiservice.go b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiservice.go new file mode 100644 index 000000000..a5e76412e --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/apiservice.go @@ -0,0 +1,184 @@ +/* +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 client-gen. DO NOT EDIT. + +package v1beta1 + +import ( + "context" + "time" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" + v1beta1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1" + scheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme" +) + +// APIServicesGetter has a method to return a APIServiceInterface. +// A group's client should implement this interface. +type APIServicesGetter interface { + APIServices() APIServiceInterface +} + +// APIServiceInterface has methods to work with APIService resources. +type APIServiceInterface interface { + Create(ctx context.Context, aPIService *v1beta1.APIService, opts v1.CreateOptions) (*v1beta1.APIService, error) + Update(ctx context.Context, aPIService *v1beta1.APIService, opts v1.UpdateOptions) (*v1beta1.APIService, error) + UpdateStatus(ctx context.Context, aPIService *v1beta1.APIService, opts v1.UpdateOptions) (*v1beta1.APIService, error) + Delete(ctx context.Context, name string, opts v1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error + Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.APIService, error) + List(ctx context.Context, opts v1.ListOptions) (*v1beta1.APIServiceList, error) + Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.APIService, err error) + APIServiceExpansion +} + +// aPIServices implements APIServiceInterface +type aPIServices struct { + client rest.Interface +} + +// newAPIServices returns a APIServices +func newAPIServices(c *ApiregistrationV1beta1Client) *aPIServices { + return &aPIServices{ + client: c.RESTClient(), + } +} + +// Get takes name of the aPIService, and returns the corresponding aPIService object, and an error if there is any. +func (c *aPIServices) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta1.APIService, err error) { + result = &v1beta1.APIService{} + err = c.client.Get(). + Resource("apiservices"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of APIServices that match those selectors. +func (c *aPIServices) List(ctx context.Context, opts v1.ListOptions) (result *v1beta1.APIServiceList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1beta1.APIServiceList{} + err = c.client.Get(). + Resource("apiservices"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested aPIServices. +func (c *aPIServices) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("apiservices"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a aPIService and creates it. Returns the server's representation of the aPIService, and an error, if there is any. +func (c *aPIServices) Create(ctx context.Context, aPIService *v1beta1.APIService, opts v1.CreateOptions) (result *v1beta1.APIService, err error) { + result = &v1beta1.APIService{} + err = c.client.Post(). + Resource("apiservices"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(aPIService). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a aPIService and updates it. Returns the server's representation of the aPIService, and an error, if there is any. +func (c *aPIServices) Update(ctx context.Context, aPIService *v1beta1.APIService, opts v1.UpdateOptions) (result *v1beta1.APIService, err error) { + result = &v1beta1.APIService{} + err = c.client.Put(). + Resource("apiservices"). + Name(aPIService.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(aPIService). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *aPIServices) UpdateStatus(ctx context.Context, aPIService *v1beta1.APIService, opts v1.UpdateOptions) (result *v1beta1.APIService, err error) { + result = &v1beta1.APIService{} + err = c.client.Put(). + Resource("apiservices"). + Name(aPIService.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(aPIService). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the aPIService and deletes it. Returns an error if one occurs. +func (c *aPIServices) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + return c.client.Delete(). + Resource("apiservices"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *aPIServices) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("apiservices"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched aPIService. +func (c *aPIServices) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1beta1.APIService, err error) { + result = &v1beta1.APIService{} + err = c.client.Patch(pt). + Resource("apiservices"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/doc.go b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/doc.go new file mode 100644 index 000000000..771101956 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/doc.go @@ -0,0 +1,20 @@ +/* +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 client-gen. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v1beta1 diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/generated_expansion.go b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/generated_expansion.go new file mode 100644 index 000000000..e9108c5c8 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1/generated_expansion.go @@ -0,0 +1,21 @@ +/* +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 client-gen. DO NOT EDIT. + +package v1beta1 + +type APIServiceExpansion interface{} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/interface.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/interface.go new file mode 100644 index 000000000..55f854a66 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/interface.go @@ -0,0 +1,54 @@ +/* +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 apiregistration + +import ( + v1 "k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1" + v1beta1 "k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1" + internalinterfaces "k8s.io/kube-aggregator/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 + // V1 provides access to shared informers for resources in V1. + V1() v1.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) +} + +// V1 returns a new v1.Interface. +func (g *group) V1() v1.Interface { + return v1.New(g.factory, g.namespace, g.tweakListOptions) +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/apiservice.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/apiservice.go new file mode 100644 index 000000000..1c6a5cf20 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/apiservice.go @@ -0,0 +1,89 @@ +/* +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 v1 + +import ( + "context" + time "time" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" + apiregistrationv1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1" + clientset "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset" + internalinterfaces "k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces" + v1 "k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1" +) + +// APIServiceInformer provides access to a shared informer and lister for +// APIServices. +type APIServiceInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.APIServiceLister +} + +type aPIServiceInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewAPIServiceInformer constructs a new informer for APIService 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 NewAPIServiceInformer(client clientset.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredAPIServiceInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredAPIServiceInformer constructs a new informer for APIService 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 NewFilteredAPIServiceInformer(client clientset.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ApiregistrationV1().APIServices().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ApiregistrationV1().APIServices().Watch(context.TODO(), options) + }, + }, + &apiregistrationv1.APIService{}, + resyncPeriod, + indexers, + ) +} + +func (f *aPIServiceInformer) defaultInformer(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredAPIServiceInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *aPIServiceInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apiregistrationv1.APIService{}, f.defaultInformer) +} + +func (f *aPIServiceInformer) Lister() v1.APIServiceLister { + return v1.NewAPIServiceLister(f.Informer().GetIndexer()) +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/interface.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/interface.go new file mode 100644 index 000000000..d0cf786ef --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1/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 v1 + +import ( + internalinterfaces "k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // APIServices returns a APIServiceInformer. + APIServices() APIServiceInformer +} + +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} +} + +// APIServices returns a APIServiceInformer. +func (v *version) APIServices() APIServiceInformer { + return &aPIServiceInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/apiservice.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/apiservice.go new file mode 100644 index 000000000..aab505a25 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/apiservice.go @@ -0,0 +1,89 @@ +/* +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 ( + "context" + time "time" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" + apiregistrationv1beta1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1" + clientset "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset" + internalinterfaces "k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces" + v1beta1 "k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1" +) + +// APIServiceInformer provides access to a shared informer and lister for +// APIServices. +type APIServiceInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1beta1.APIServiceLister +} + +type aPIServiceInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewAPIServiceInformer constructs a new informer for APIService 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 NewAPIServiceInformer(client clientset.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredAPIServiceInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredAPIServiceInformer constructs a new informer for APIService 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 NewFilteredAPIServiceInformer(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.ApiregistrationV1beta1().APIServices().List(context.TODO(), options) + }, + WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.ApiregistrationV1beta1().APIServices().Watch(context.TODO(), options) + }, + }, + &apiregistrationv1beta1.APIService{}, + resyncPeriod, + indexers, + ) +} + +func (f *aPIServiceInformer) defaultInformer(client clientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredAPIServiceInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *aPIServiceInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&apiregistrationv1beta1.APIService{}, f.defaultInformer) +} + +func (f *aPIServiceInformer) Lister() v1beta1.APIServiceLister { + return v1beta1.NewAPIServiceLister(f.Informer().GetIndexer()) +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/interface.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1/interface.go new file mode 100644 index 000000000..d9f6fc380 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/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/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces" +) + +// Interface provides access to all the informers in this group version. +type Interface interface { + // APIServices returns a APIServiceInformer. + APIServices() APIServiceInformer +} + +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} +} + +// APIServices returns a APIServiceInformer. +func (v *version) APIServices() APIServiceInformer { + return &aPIServiceInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/factory.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/factory.go new file mode 100644 index 000000000..88cb2bdec --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/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" + + 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" + clientset "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset" + apiregistration "k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration" + internalinterfaces "k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces" +) + +// 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 + + Apiregistration() apiregistration.Interface +} + +func (f *sharedInformerFactory) Apiregistration() apiregistration.Interface { + return apiregistration.New(f, f.namespace, f.tweakListOptions) +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/generic.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/generic.go new file mode 100644 index 000000000..1c89767b2 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/generic.go @@ -0,0 +1,67 @@ +/* +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" + + schema "k8s.io/apimachinery/pkg/runtime/schema" + cache "k8s.io/client-go/tools/cache" + v1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1" + v1beta1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1" +) + +// 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=apiregistration.k8s.io, Version=v1 + case v1.SchemeGroupVersion.WithResource("apiservices"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Apiregistration().V1().APIServices().Informer()}, nil + + // Group=apiregistration.k8s.io, Version=v1beta1 + case v1beta1.SchemeGroupVersion.WithResource("apiservices"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Apiregistration().V1beta1().APIServices().Informer()}, nil + + } + + return nil, fmt.Errorf("no informer found for %v", resource) +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go new file mode 100644 index 000000000..5fd2bca8c --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go @@ -0,0 +1,40 @@ +/* +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" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + cache "k8s.io/client-go/tools/cache" + clientset "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset" +) + +// NewInformerFunc takes clientset.Interface and time.Duration to return a SharedIndexInformer. +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 +} + +// TweakListOptionsFunc is a function that transforms a v1.ListOptions. +type TweakListOptionsFunc func(*v1.ListOptions) diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/apiservice.go b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/apiservice.go new file mode 100644 index 000000000..b2e4f763c --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/apiservice.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 v1 + +import ( + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" + v1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1" +) + +// APIServiceLister helps list APIServices. +type APIServiceLister interface { + // List lists all APIServices in the indexer. + List(selector labels.Selector) (ret []*v1.APIService, err error) + // Get retrieves the APIService from the index for a given name. + Get(name string) (*v1.APIService, error) + APIServiceListerExpansion +} + +// aPIServiceLister implements the APIServiceLister interface. +type aPIServiceLister struct { + indexer cache.Indexer +} + +// NewAPIServiceLister returns a new APIServiceLister. +func NewAPIServiceLister(indexer cache.Indexer) APIServiceLister { + return &aPIServiceLister{indexer: indexer} +} + +// List lists all APIServices in the indexer. +func (s *aPIServiceLister) List(selector labels.Selector) (ret []*v1.APIService, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.APIService)) + }) + return ret, err +} + +// Get retrieves the APIService from the index for a given name. +func (s *aPIServiceLister) Get(name string) (*v1.APIService, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("apiservice"), name) + } + return obj.(*v1.APIService), nil +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/expansion_generated.go b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/expansion_generated.go new file mode 100644 index 000000000..07d5e73b9 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1/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 v1 + +// APIServiceListerExpansion allows custom methods to be added to +// APIServiceLister. +type APIServiceListerExpansion interface{} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/apiservice.go b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/apiservice.go new file mode 100644 index 000000000..57f930383 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/apiservice.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 ( + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" + v1beta1 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1" +) + +// APIServiceLister helps list APIServices. +type APIServiceLister interface { + // List lists all APIServices in the indexer. + List(selector labels.Selector) (ret []*v1beta1.APIService, err error) + // Get retrieves the APIService from the index for a given name. + Get(name string) (*v1beta1.APIService, error) + APIServiceListerExpansion +} + +// aPIServiceLister implements the APIServiceLister interface. +type aPIServiceLister struct { + indexer cache.Indexer +} + +// NewAPIServiceLister returns a new APIServiceLister. +func NewAPIServiceLister(indexer cache.Indexer) APIServiceLister { + return &aPIServiceLister{indexer: indexer} +} + +// List lists all APIServices in the indexer. +func (s *aPIServiceLister) List(selector labels.Selector) (ret []*v1beta1.APIService, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1beta1.APIService)) + }) + return ret, err +} + +// Get retrieves the APIService from the index for a given name. +func (s *aPIServiceLister) Get(name string) (*v1beta1.APIService, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1beta1.Resource("apiservice"), name) + } + return obj.(*v1beta1.APIService), nil +} diff --git a/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/expansion_generated.go b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1/expansion_generated.go new file mode 100644 index 000000000..6c7d75f61 --- /dev/null +++ b/vendor/k8s.io/kube-aggregator/pkg/client/listers/apiregistration/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 + +// APIServiceListerExpansion allows custom methods to be added to +// APIServiceLister. +type APIServiceListerExpansion interface{} diff --git a/vendor/modules.txt b/vendor/modules.txt index 8ea76d0d8..9efe0a12b 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -198,6 +198,8 @@ github.com/openshift/library-go/pkg/oauth/oauthdiscovery github.com/openshift/library-go/pkg/operator/condition github.com/openshift/library-go/pkg/operator/configobserver github.com/openshift/library-go/pkg/operator/configobserver/apiserver +github.com/openshift/library-go/pkg/operator/encryption/secrets +github.com/openshift/library-go/pkg/operator/encryption/state github.com/openshift/library-go/pkg/operator/events github.com/openshift/library-go/pkg/operator/events/eventstesting github.com/openshift/library-go/pkg/operator/loglevel @@ -369,7 +371,7 @@ gopkg.in/natefinch/lumberjack.v2 gopkg.in/square/go-jose.v2/json # gopkg.in/yaml.v2 v2.2.8 gopkg.in/yaml.v2 -# k8s.io/api v0.18.2 +# k8s.io/api v0.18.6 k8s.io/api/admission/v1 k8s.io/api/admission/v1beta1 k8s.io/api/admissionregistration/v1 @@ -421,7 +423,7 @@ k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/scheme k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1 k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1 -# k8s.io/apimachinery v0.18.2 +# k8s.io/apimachinery v0.18.6 k8s.io/apimachinery/pkg/api/equality k8s.io/apimachinery/pkg/api/errors k8s.io/apimachinery/pkg/api/meta @@ -473,7 +475,7 @@ k8s.io/apimachinery/pkg/version k8s.io/apimachinery/pkg/watch k8s.io/apimachinery/third_party/forked/golang/json k8s.io/apimachinery/third_party/forked/golang/reflect -# k8s.io/apiserver v0.18.2 +# k8s.io/apiserver v0.18.6 k8s.io/apiserver/pkg/admission k8s.io/apiserver/pkg/admission/configuration k8s.io/apiserver/pkg/admission/initializer @@ -594,7 +596,7 @@ k8s.io/apiserver/plugin/pkg/audit/truncate k8s.io/apiserver/plugin/pkg/audit/webhook k8s.io/apiserver/plugin/pkg/authenticator/token/webhook k8s.io/apiserver/plugin/pkg/authorizer/webhook -# k8s.io/client-go v0.18.2 +# k8s.io/client-go v0.18.6 k8s.io/client-go/discovery k8s.io/client-go/discovery/fake k8s.io/client-go/dynamic @@ -804,7 +806,7 @@ k8s.io/client-go/util/homedir k8s.io/client-go/util/keyutil k8s.io/client-go/util/retry k8s.io/client-go/util/workqueue -# k8s.io/component-base v0.18.2 +# k8s.io/component-base v0.18.6 k8s.io/component-base/cli/flag k8s.io/component-base/featuregate k8s.io/component-base/logs @@ -814,13 +816,22 @@ k8s.io/component-base/metrics/testutil k8s.io/component-base/version # k8s.io/klog v1.0.0 k8s.io/klog -# k8s.io/kube-aggregator v0.18.2 +# k8s.io/kube-aggregator v0.18.6 k8s.io/kube-aggregator/pkg/apis/apiregistration k8s.io/kube-aggregator/pkg/apis/apiregistration/v1 k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1 +k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1 -# k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c +k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/typed/apiregistration/v1beta1 +k8s.io/kube-aggregator/pkg/client/informers/externalversions +k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration +k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1 +k8s.io/kube-aggregator/pkg/client/informers/externalversions/apiregistration/v1beta1 +k8s.io/kube-aggregator/pkg/client/informers/externalversions/internalinterfaces +k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1 +k8s.io/kube-aggregator/pkg/client/listers/apiregistration/v1beta1 +# k8s.io/kube-openapi v0.0.0-20200410145947-61e04a5be9a6 k8s.io/kube-openapi/pkg/builder k8s.io/kube-openapi/pkg/common k8s.io/kube-openapi/pkg/handler