From c9122eb1a6cab12e88ece4b8a8eb22cd93cbe1af Mon Sep 17 00:00:00 2001 From: Joshua Pritchard <53924645+josh-pritchard@users.noreply.github.com> Date: Thu, 11 Jan 2024 19:23:15 -0500 Subject: [PATCH] Add istio telemetry API (#40) --- codegen/istio_groups.go | 13 + .../telemetry.istio.io/v1alpha1/clients.go | 214 +++++++ .../v1alpha1/controller/event_handlers.go | 125 ++++ .../controller/mocks/event_handlers.go | 136 ++++ .../mocks/multicluster_reconcilers.go | 131 ++++ .../v1alpha1/controller/mocks/reconcilers.go | 199 ++++++ .../controller/multicluster_reconcilers.go | 90 +++ .../v1alpha1/controller/reconcilers.go | 135 ++++ .../v1alpha1/mocks/clients.go | 594 ++++++++++++++++++ .../v1alpha1/providers/client_providers.go | 46 ++ .../v1alpha1/sets/mocks/sets.go | 272 ++++++++ .../telemetry.istio.io/v1alpha1/sets/sets.go | 235 +++++++ .../v1alpha1/type_helpers.go | 11 + 13 files changed, 2201 insertions(+) create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/clients.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/controller/event_handlers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/event_handlers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/multicluster_reconcilers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/reconcilers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/controller/multicluster_reconcilers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/controller/reconcilers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/mocks/clients.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/providers/client_providers.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/sets/mocks/sets.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/sets/sets.go create mode 100644 pkg/api/istio/telemetry.istio.io/v1alpha1/type_helpers.go diff --git a/codegen/istio_groups.go b/codegen/istio_groups.go index 806a361..2664436 100644 --- a/codegen/istio_groups.go +++ b/codegen/istio_groups.go @@ -5,6 +5,7 @@ import ( networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3" networkingv1beta1 "istio.io/client-go/pkg/apis/networking/v1beta1" "istio.io/client-go/pkg/apis/security/v1beta1" + istiotelemetryv1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" operator "istio.io/istio/operator/pkg/apis/istio/v1alpha1" ) @@ -87,5 +88,17 @@ func istioGroups() []model.Group { CustomTypesImportPath: "istio.io/istio/operator/pkg/apis/istio/v1alpha1", ApiRoot: istioApiRoot, }, + { + GroupVersion: istiotelemetryv1alpha1.SchemeGroupVersion, + Module: istioModule, + Resources: []model.Resource{ + { + Kind: "Telemetry", + }, + }, + CustomTypesImportPath: "istio.io/client-go/pkg/apis/telemetry/v1alpha1", + ApiRoot: istioApiRoot, + PointerSlices: true, + }, } } diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/clients.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/clients.go new file mode 100644 index 0000000..ea9c2d6 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/clients.go @@ -0,0 +1,214 @@ +// Code generated by skv2. DO NOT EDIT. + +//go:generate mockgen -source ./clients.go -destination mocks/clients.go + +package v1alpha1 + +import ( + "context" + + "github.com/solo-io/skv2/pkg/controllerutils" + "github.com/solo-io/skv2/pkg/multicluster" + telemetry_istio_io_v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/kubernetes/scheme" + "k8s.io/client-go/rest" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +// MulticlusterClientset for the telemetry.istio.io/v1alpha1 APIs +type MulticlusterClientset interface { + // Cluster returns a Clientset for the given cluster + Cluster(cluster string) (Clientset, error) +} + +type multiclusterClientset struct { + client multicluster.Client +} + +func NewMulticlusterClientset(client multicluster.Client) MulticlusterClientset { + return &multiclusterClientset{client: client} +} + +func (m *multiclusterClientset) Cluster(cluster string) (Clientset, error) { + client, err := m.client.Cluster(cluster) + if err != nil { + return nil, err + } + return NewClientset(client), nil +} + +// clienset for the telemetry.istio.io/v1alpha1 APIs +type Clientset interface { + // clienset for the telemetry.istio.io/v1alpha1/v1alpha1 APIs + Telemetries() TelemetryClient +} + +type clientSet struct { + client client.Client +} + +func NewClientsetFromConfig(cfg *rest.Config) (Clientset, error) { + scheme := scheme.Scheme + if err := telemetry_istio_io_v1alpha1.SchemeBuilder.AddToScheme(scheme); err != nil { + return nil, err + } + client, err := client.New(cfg, client.Options{ + Scheme: scheme, + }) + if err != nil { + return nil, err + } + return NewClientset(client), nil +} + +func NewClientset(client client.Client) Clientset { + return &clientSet{client: client} +} + +// clienset for the telemetry.istio.io/v1alpha1/v1alpha1 APIs +func (c *clientSet) Telemetries() TelemetryClient { + return NewTelemetryClient(c.client) +} + +// Reader knows how to read and list Telemetrys. +type TelemetryReader interface { + // Get retrieves a Telemetry for the given object key + GetTelemetry(ctx context.Context, key client.ObjectKey) (*telemetry_istio_io_v1alpha1.Telemetry, error) + + // List retrieves list of Telemetrys for a given namespace and list options. + ListTelemetry(ctx context.Context, opts ...client.ListOption) (*telemetry_istio_io_v1alpha1.TelemetryList, error) +} + +// TelemetryTransitionFunction instructs the TelemetryWriter how to transition between an existing +// Telemetry object and a desired on an Upsert +type TelemetryTransitionFunction func(existing, desired *telemetry_istio_io_v1alpha1.Telemetry) error + +// Writer knows how to create, delete, and update Telemetrys. +type TelemetryWriter interface { + // Create saves the Telemetry object. + CreateTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, opts ...client.CreateOption) error + + // Delete deletes the Telemetry object. + DeleteTelemetry(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error + + // Update updates the given Telemetry object. + UpdateTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, opts ...client.UpdateOption) error + + // Patch patches the given Telemetry object. + PatchTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, patch client.Patch, opts ...client.PatchOption) error + + // DeleteAllOf deletes all Telemetry objects matching the given options. + DeleteAllOfTelemetry(ctx context.Context, opts ...client.DeleteAllOfOption) error + + // Create or Update the Telemetry object. + UpsertTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, transitionFuncs ...TelemetryTransitionFunction) error +} + +// StatusWriter knows how to update status subresource of a Telemetry object. +type TelemetryStatusWriter interface { + // Update updates the fields corresponding to the status subresource for the + // given Telemetry object. + UpdateTelemetryStatus(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, opts ...client.SubResourceUpdateOption) error + + // Patch patches the given Telemetry object's subresource. + PatchTelemetryStatus(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, patch client.Patch, opts ...client.SubResourcePatchOption) error +} + +// Client knows how to perform CRUD operations on Telemetrys. +type TelemetryClient interface { + TelemetryReader + TelemetryWriter + TelemetryStatusWriter +} + +type telemetryClient struct { + client client.Client +} + +func NewTelemetryClient(client client.Client) *telemetryClient { + return &telemetryClient{client: client} +} + +func (c *telemetryClient) GetTelemetry(ctx context.Context, key client.ObjectKey) (*telemetry_istio_io_v1alpha1.Telemetry, error) { + obj := &telemetry_istio_io_v1alpha1.Telemetry{} + if err := c.client.Get(ctx, key, obj); err != nil { + return nil, err + } + return obj, nil +} + +func (c *telemetryClient) ListTelemetry(ctx context.Context, opts ...client.ListOption) (*telemetry_istio_io_v1alpha1.TelemetryList, error) { + list := &telemetry_istio_io_v1alpha1.TelemetryList{} + if err := c.client.List(ctx, list, opts...); err != nil { + return nil, err + } + return list, nil +} + +func (c *telemetryClient) CreateTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, opts ...client.CreateOption) error { + return c.client.Create(ctx, obj, opts...) +} + +func (c *telemetryClient) DeleteTelemetry(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error { + obj := &telemetry_istio_io_v1alpha1.Telemetry{} + obj.SetName(key.Name) + obj.SetNamespace(key.Namespace) + return c.client.Delete(ctx, obj, opts...) +} + +func (c *telemetryClient) UpdateTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, opts ...client.UpdateOption) error { + return c.client.Update(ctx, obj, opts...) +} + +func (c *telemetryClient) PatchTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, patch client.Patch, opts ...client.PatchOption) error { + return c.client.Patch(ctx, obj, patch, opts...) +} + +func (c *telemetryClient) DeleteAllOfTelemetry(ctx context.Context, opts ...client.DeleteAllOfOption) error { + obj := &telemetry_istio_io_v1alpha1.Telemetry{} + return c.client.DeleteAllOf(ctx, obj, opts...) +} + +func (c *telemetryClient) UpsertTelemetry(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, transitionFuncs ...TelemetryTransitionFunction) error { + genericTxFunc := func(existing, desired runtime.Object) error { + for _, txFunc := range transitionFuncs { + if err := txFunc(existing.(*telemetry_istio_io_v1alpha1.Telemetry), desired.(*telemetry_istio_io_v1alpha1.Telemetry)); err != nil { + return err + } + } + return nil + } + _, err := controllerutils.Upsert(ctx, c.client, obj, genericTxFunc) + return err +} + +func (c *telemetryClient) UpdateTelemetryStatus(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, opts ...client.SubResourceUpdateOption) error { + return c.client.Status().Update(ctx, obj, opts...) +} + +func (c *telemetryClient) PatchTelemetryStatus(ctx context.Context, obj *telemetry_istio_io_v1alpha1.Telemetry, patch client.Patch, opts ...client.SubResourcePatchOption) error { + return c.client.Status().Patch(ctx, obj, patch, opts...) +} + +// Provides TelemetryClients for multiple clusters. +type MulticlusterTelemetryClient interface { + // Cluster returns a TelemetryClient for the given cluster + Cluster(cluster string) (TelemetryClient, error) +} + +type multiclusterTelemetryClient struct { + client multicluster.Client +} + +func NewMulticlusterTelemetryClient(client multicluster.Client) MulticlusterTelemetryClient { + return &multiclusterTelemetryClient{client: client} +} + +func (m *multiclusterTelemetryClient) Cluster(cluster string) (TelemetryClient, error) { + client, err := m.client.Cluster(cluster) + if err != nil { + return nil, err + } + return NewTelemetryClient(client), nil +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/event_handlers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/event_handlers.go new file mode 100644 index 0000000..8d5ccbc --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/event_handlers.go @@ -0,0 +1,125 @@ +// Code generated by skv2. DO NOT EDIT. + +//go:generate mockgen -source ./event_handlers.go -destination mocks/event_handlers.go + +// Definitions for the Kubernetes Controllers +package controller + +import ( + "context" + + telemetry_istio_io_v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + + "github.com/pkg/errors" + "github.com/solo-io/skv2/pkg/events" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/manager" + "sigs.k8s.io/controller-runtime/pkg/predicate" +) + +// Handle events for the Telemetry Resource +// DEPRECATED: Prefer reconciler pattern. +type TelemetryEventHandler interface { + CreateTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error + UpdateTelemetry(old, new *telemetry_istio_io_v1alpha1.Telemetry) error + DeleteTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error + GenericTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error +} + +type TelemetryEventHandlerFuncs struct { + OnCreate func(obj *telemetry_istio_io_v1alpha1.Telemetry) error + OnUpdate func(old, new *telemetry_istio_io_v1alpha1.Telemetry) error + OnDelete func(obj *telemetry_istio_io_v1alpha1.Telemetry) error + OnGeneric func(obj *telemetry_istio_io_v1alpha1.Telemetry) error +} + +func (f *TelemetryEventHandlerFuncs) CreateTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error { + if f.OnCreate == nil { + return nil + } + return f.OnCreate(obj) +} + +func (f *TelemetryEventHandlerFuncs) DeleteTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error { + if f.OnDelete == nil { + return nil + } + return f.OnDelete(obj) +} + +func (f *TelemetryEventHandlerFuncs) UpdateTelemetry(objOld, objNew *telemetry_istio_io_v1alpha1.Telemetry) error { + if f.OnUpdate == nil { + return nil + } + return f.OnUpdate(objOld, objNew) +} + +func (f *TelemetryEventHandlerFuncs) GenericTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error { + if f.OnGeneric == nil { + return nil + } + return f.OnGeneric(obj) +} + +type TelemetryEventWatcher interface { + AddEventHandler(ctx context.Context, h TelemetryEventHandler, predicates ...predicate.Predicate) error +} + +type telemetryEventWatcher struct { + watcher events.EventWatcher +} + +func NewTelemetryEventWatcher(name string, mgr manager.Manager) TelemetryEventWatcher { + return &telemetryEventWatcher{ + watcher: events.NewWatcher(name, mgr, &telemetry_istio_io_v1alpha1.Telemetry{}), + } +} + +func (c *telemetryEventWatcher) AddEventHandler(ctx context.Context, h TelemetryEventHandler, predicates ...predicate.Predicate) error { + handler := genericTelemetryHandler{handler: h} + if err := c.watcher.Watch(ctx, handler, predicates...); err != nil { + return err + } + return nil +} + +// genericTelemetryHandler implements a generic events.EventHandler +type genericTelemetryHandler struct { + handler TelemetryEventHandler +} + +func (h genericTelemetryHandler) Create(object client.Object) error { + obj, ok := object.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return errors.Errorf("internal error: Telemetry handler received event for %T", object) + } + return h.handler.CreateTelemetry(obj) +} + +func (h genericTelemetryHandler) Delete(object client.Object) error { + obj, ok := object.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return errors.Errorf("internal error: Telemetry handler received event for %T", object) + } + return h.handler.DeleteTelemetry(obj) +} + +func (h genericTelemetryHandler) Update(old, new client.Object) error { + objOld, ok := old.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return errors.Errorf("internal error: Telemetry handler received event for %T", old) + } + objNew, ok := new.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return errors.Errorf("internal error: Telemetry handler received event for %T", new) + } + return h.handler.UpdateTelemetry(objOld, objNew) +} + +func (h genericTelemetryHandler) Generic(object client.Object) error { + obj, ok := object.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return errors.Errorf("internal error: Telemetry handler received event for %T", object) + } + return h.handler.GenericTelemetry(obj) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/event_handlers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/event_handlers.go new file mode 100644 index 0000000..bfa58d8 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/event_handlers.go @@ -0,0 +1,136 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./event_handlers.go + +// Package mock_controller is a generated GoMock package. +package mock_controller + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + controller "github.com/solo-io/external-apis/pkg/api/istio/telemetry.istio.io/v1alpha1/controller" + v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + predicate "sigs.k8s.io/controller-runtime/pkg/predicate" +) + +// MockTelemetryEventHandler is a mock of TelemetryEventHandler interface. +type MockTelemetryEventHandler struct { + ctrl *gomock.Controller + recorder *MockTelemetryEventHandlerMockRecorder +} + +// MockTelemetryEventHandlerMockRecorder is the mock recorder for MockTelemetryEventHandler. +type MockTelemetryEventHandlerMockRecorder struct { + mock *MockTelemetryEventHandler +} + +// NewMockTelemetryEventHandler creates a new mock instance. +func NewMockTelemetryEventHandler(ctrl *gomock.Controller) *MockTelemetryEventHandler { + mock := &MockTelemetryEventHandler{ctrl: ctrl} + mock.recorder = &MockTelemetryEventHandlerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryEventHandler) EXPECT() *MockTelemetryEventHandlerMockRecorder { + return m.recorder +} + +// CreateTelemetry mocks base method. +func (m *MockTelemetryEventHandler) CreateTelemetry(obj *v1alpha1.Telemetry) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTelemetry", obj) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateTelemetry indicates an expected call of CreateTelemetry. +func (mr *MockTelemetryEventHandlerMockRecorder) CreateTelemetry(obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTelemetry", reflect.TypeOf((*MockTelemetryEventHandler)(nil).CreateTelemetry), obj) +} + +// DeleteTelemetry mocks base method. +func (m *MockTelemetryEventHandler) DeleteTelemetry(obj *v1alpha1.Telemetry) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTelemetry", obj) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteTelemetry indicates an expected call of DeleteTelemetry. +func (mr *MockTelemetryEventHandlerMockRecorder) DeleteTelemetry(obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTelemetry", reflect.TypeOf((*MockTelemetryEventHandler)(nil).DeleteTelemetry), obj) +} + +// GenericTelemetry mocks base method. +func (m *MockTelemetryEventHandler) GenericTelemetry(obj *v1alpha1.Telemetry) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenericTelemetry", obj) + ret0, _ := ret[0].(error) + return ret0 +} + +// GenericTelemetry indicates an expected call of GenericTelemetry. +func (mr *MockTelemetryEventHandlerMockRecorder) GenericTelemetry(obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenericTelemetry", reflect.TypeOf((*MockTelemetryEventHandler)(nil).GenericTelemetry), obj) +} + +// UpdateTelemetry mocks base method. +func (m *MockTelemetryEventHandler) UpdateTelemetry(old, new *v1alpha1.Telemetry) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTelemetry", old, new) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTelemetry indicates an expected call of UpdateTelemetry. +func (mr *MockTelemetryEventHandlerMockRecorder) UpdateTelemetry(old, new interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTelemetry", reflect.TypeOf((*MockTelemetryEventHandler)(nil).UpdateTelemetry), old, new) +} + +// MockTelemetryEventWatcher is a mock of TelemetryEventWatcher interface. +type MockTelemetryEventWatcher struct { + ctrl *gomock.Controller + recorder *MockTelemetryEventWatcherMockRecorder +} + +// MockTelemetryEventWatcherMockRecorder is the mock recorder for MockTelemetryEventWatcher. +type MockTelemetryEventWatcherMockRecorder struct { + mock *MockTelemetryEventWatcher +} + +// NewMockTelemetryEventWatcher creates a new mock instance. +func NewMockTelemetryEventWatcher(ctrl *gomock.Controller) *MockTelemetryEventWatcher { + mock := &MockTelemetryEventWatcher{ctrl: ctrl} + mock.recorder = &MockTelemetryEventWatcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryEventWatcher) EXPECT() *MockTelemetryEventWatcherMockRecorder { + return m.recorder +} + +// AddEventHandler mocks base method. +func (m *MockTelemetryEventWatcher) AddEventHandler(ctx context.Context, h controller.TelemetryEventHandler, predicates ...predicate.Predicate) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, h} + for _, a := range predicates { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddEventHandler", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddEventHandler indicates an expected call of AddEventHandler. +func (mr *MockTelemetryEventWatcherMockRecorder) AddEventHandler(ctx, h interface{}, predicates ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, h}, predicates...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEventHandler", reflect.TypeOf((*MockTelemetryEventWatcher)(nil).AddEventHandler), varargs...) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/multicluster_reconcilers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/multicluster_reconcilers.go new file mode 100644 index 0000000..20d0b47 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/multicluster_reconcilers.go @@ -0,0 +1,131 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./multicluster_reconcilers.go + +// Package mock_controller is a generated GoMock package. +package mock_controller + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + controller "github.com/solo-io/external-apis/pkg/api/istio/telemetry.istio.io/v1alpha1/controller" + reconcile "github.com/solo-io/skv2/pkg/reconcile" + v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + predicate "sigs.k8s.io/controller-runtime/pkg/predicate" +) + +// MockMulticlusterTelemetryReconciler is a mock of MulticlusterTelemetryReconciler interface. +type MockMulticlusterTelemetryReconciler struct { + ctrl *gomock.Controller + recorder *MockMulticlusterTelemetryReconcilerMockRecorder +} + +// MockMulticlusterTelemetryReconcilerMockRecorder is the mock recorder for MockMulticlusterTelemetryReconciler. +type MockMulticlusterTelemetryReconcilerMockRecorder struct { + mock *MockMulticlusterTelemetryReconciler +} + +// NewMockMulticlusterTelemetryReconciler creates a new mock instance. +func NewMockMulticlusterTelemetryReconciler(ctrl *gomock.Controller) *MockMulticlusterTelemetryReconciler { + mock := &MockMulticlusterTelemetryReconciler{ctrl: ctrl} + mock.recorder = &MockMulticlusterTelemetryReconcilerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMulticlusterTelemetryReconciler) EXPECT() *MockMulticlusterTelemetryReconcilerMockRecorder { + return m.recorder +} + +// ReconcileTelemetry mocks base method. +func (m *MockMulticlusterTelemetryReconciler) ReconcileTelemetry(clusterName string, obj *v1alpha1.Telemetry) (reconcile.Result, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconcileTelemetry", clusterName, obj) + ret0, _ := ret[0].(reconcile.Result) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReconcileTelemetry indicates an expected call of ReconcileTelemetry. +func (mr *MockMulticlusterTelemetryReconcilerMockRecorder) ReconcileTelemetry(clusterName, obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileTelemetry", reflect.TypeOf((*MockMulticlusterTelemetryReconciler)(nil).ReconcileTelemetry), clusterName, obj) +} + +// MockMulticlusterTelemetryDeletionReconciler is a mock of MulticlusterTelemetryDeletionReconciler interface. +type MockMulticlusterTelemetryDeletionReconciler struct { + ctrl *gomock.Controller + recorder *MockMulticlusterTelemetryDeletionReconcilerMockRecorder +} + +// MockMulticlusterTelemetryDeletionReconcilerMockRecorder is the mock recorder for MockMulticlusterTelemetryDeletionReconciler. +type MockMulticlusterTelemetryDeletionReconcilerMockRecorder struct { + mock *MockMulticlusterTelemetryDeletionReconciler +} + +// NewMockMulticlusterTelemetryDeletionReconciler creates a new mock instance. +func NewMockMulticlusterTelemetryDeletionReconciler(ctrl *gomock.Controller) *MockMulticlusterTelemetryDeletionReconciler { + mock := &MockMulticlusterTelemetryDeletionReconciler{ctrl: ctrl} + mock.recorder = &MockMulticlusterTelemetryDeletionReconcilerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMulticlusterTelemetryDeletionReconciler) EXPECT() *MockMulticlusterTelemetryDeletionReconcilerMockRecorder { + return m.recorder +} + +// ReconcileTelemetryDeletion mocks base method. +func (m *MockMulticlusterTelemetryDeletionReconciler) ReconcileTelemetryDeletion(clusterName string, req reconcile.Request) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconcileTelemetryDeletion", clusterName, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReconcileTelemetryDeletion indicates an expected call of ReconcileTelemetryDeletion. +func (mr *MockMulticlusterTelemetryDeletionReconcilerMockRecorder) ReconcileTelemetryDeletion(clusterName, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileTelemetryDeletion", reflect.TypeOf((*MockMulticlusterTelemetryDeletionReconciler)(nil).ReconcileTelemetryDeletion), clusterName, req) +} + +// MockMulticlusterTelemetryReconcileLoop is a mock of MulticlusterTelemetryReconcileLoop interface. +type MockMulticlusterTelemetryReconcileLoop struct { + ctrl *gomock.Controller + recorder *MockMulticlusterTelemetryReconcileLoopMockRecorder +} + +// MockMulticlusterTelemetryReconcileLoopMockRecorder is the mock recorder for MockMulticlusterTelemetryReconcileLoop. +type MockMulticlusterTelemetryReconcileLoopMockRecorder struct { + mock *MockMulticlusterTelemetryReconcileLoop +} + +// NewMockMulticlusterTelemetryReconcileLoop creates a new mock instance. +func NewMockMulticlusterTelemetryReconcileLoop(ctrl *gomock.Controller) *MockMulticlusterTelemetryReconcileLoop { + mock := &MockMulticlusterTelemetryReconcileLoop{ctrl: ctrl} + mock.recorder = &MockMulticlusterTelemetryReconcileLoopMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMulticlusterTelemetryReconcileLoop) EXPECT() *MockMulticlusterTelemetryReconcileLoopMockRecorder { + return m.recorder +} + +// AddMulticlusterTelemetryReconciler mocks base method. +func (m *MockMulticlusterTelemetryReconcileLoop) AddMulticlusterTelemetryReconciler(ctx context.Context, rec controller.MulticlusterTelemetryReconciler, predicates ...predicate.Predicate) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, rec} + for _, a := range predicates { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "AddMulticlusterTelemetryReconciler", varargs...) +} + +// AddMulticlusterTelemetryReconciler indicates an expected call of AddMulticlusterTelemetryReconciler. +func (mr *MockMulticlusterTelemetryReconcileLoopMockRecorder) AddMulticlusterTelemetryReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, rec}, predicates...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMulticlusterTelemetryReconciler", reflect.TypeOf((*MockMulticlusterTelemetryReconcileLoop)(nil).AddMulticlusterTelemetryReconciler), varargs...) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/reconcilers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/reconcilers.go new file mode 100644 index 0000000..749abe6 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/mocks/reconcilers.go @@ -0,0 +1,199 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./reconcilers.go + +// Package mock_controller is a generated GoMock package. +package mock_controller + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + controller "github.com/solo-io/external-apis/pkg/api/istio/telemetry.istio.io/v1alpha1/controller" + reconcile "github.com/solo-io/skv2/pkg/reconcile" + v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + predicate "sigs.k8s.io/controller-runtime/pkg/predicate" +) + +// MockTelemetryReconciler is a mock of TelemetryReconciler interface. +type MockTelemetryReconciler struct { + ctrl *gomock.Controller + recorder *MockTelemetryReconcilerMockRecorder +} + +// MockTelemetryReconcilerMockRecorder is the mock recorder for MockTelemetryReconciler. +type MockTelemetryReconcilerMockRecorder struct { + mock *MockTelemetryReconciler +} + +// NewMockTelemetryReconciler creates a new mock instance. +func NewMockTelemetryReconciler(ctrl *gomock.Controller) *MockTelemetryReconciler { + mock := &MockTelemetryReconciler{ctrl: ctrl} + mock.recorder = &MockTelemetryReconcilerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryReconciler) EXPECT() *MockTelemetryReconcilerMockRecorder { + return m.recorder +} + +// ReconcileTelemetry mocks base method. +func (m *MockTelemetryReconciler) ReconcileTelemetry(obj *v1alpha1.Telemetry) (reconcile.Result, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconcileTelemetry", obj) + ret0, _ := ret[0].(reconcile.Result) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReconcileTelemetry indicates an expected call of ReconcileTelemetry. +func (mr *MockTelemetryReconcilerMockRecorder) ReconcileTelemetry(obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileTelemetry", reflect.TypeOf((*MockTelemetryReconciler)(nil).ReconcileTelemetry), obj) +} + +// MockTelemetryDeletionReconciler is a mock of TelemetryDeletionReconciler interface. +type MockTelemetryDeletionReconciler struct { + ctrl *gomock.Controller + recorder *MockTelemetryDeletionReconcilerMockRecorder +} + +// MockTelemetryDeletionReconcilerMockRecorder is the mock recorder for MockTelemetryDeletionReconciler. +type MockTelemetryDeletionReconcilerMockRecorder struct { + mock *MockTelemetryDeletionReconciler +} + +// NewMockTelemetryDeletionReconciler creates a new mock instance. +func NewMockTelemetryDeletionReconciler(ctrl *gomock.Controller) *MockTelemetryDeletionReconciler { + mock := &MockTelemetryDeletionReconciler{ctrl: ctrl} + mock.recorder = &MockTelemetryDeletionReconcilerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryDeletionReconciler) EXPECT() *MockTelemetryDeletionReconcilerMockRecorder { + return m.recorder +} + +// ReconcileTelemetryDeletion mocks base method. +func (m *MockTelemetryDeletionReconciler) ReconcileTelemetryDeletion(req reconcile.Request) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconcileTelemetryDeletion", req) + ret0, _ := ret[0].(error) + return ret0 +} + +// ReconcileTelemetryDeletion indicates an expected call of ReconcileTelemetryDeletion. +func (mr *MockTelemetryDeletionReconcilerMockRecorder) ReconcileTelemetryDeletion(req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileTelemetryDeletion", reflect.TypeOf((*MockTelemetryDeletionReconciler)(nil).ReconcileTelemetryDeletion), req) +} + +// MockTelemetryFinalizer is a mock of TelemetryFinalizer interface. +type MockTelemetryFinalizer struct { + ctrl *gomock.Controller + recorder *MockTelemetryFinalizerMockRecorder +} + +// MockTelemetryFinalizerMockRecorder is the mock recorder for MockTelemetryFinalizer. +type MockTelemetryFinalizerMockRecorder struct { + mock *MockTelemetryFinalizer +} + +// NewMockTelemetryFinalizer creates a new mock instance. +func NewMockTelemetryFinalizer(ctrl *gomock.Controller) *MockTelemetryFinalizer { + mock := &MockTelemetryFinalizer{ctrl: ctrl} + mock.recorder = &MockTelemetryFinalizerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryFinalizer) EXPECT() *MockTelemetryFinalizerMockRecorder { + return m.recorder +} + +// FinalizeTelemetry mocks base method. +func (m *MockTelemetryFinalizer) FinalizeTelemetry(obj *v1alpha1.Telemetry) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FinalizeTelemetry", obj) + ret0, _ := ret[0].(error) + return ret0 +} + +// FinalizeTelemetry indicates an expected call of FinalizeTelemetry. +func (mr *MockTelemetryFinalizerMockRecorder) FinalizeTelemetry(obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeTelemetry", reflect.TypeOf((*MockTelemetryFinalizer)(nil).FinalizeTelemetry), obj) +} + +// ReconcileTelemetry mocks base method. +func (m *MockTelemetryFinalizer) ReconcileTelemetry(obj *v1alpha1.Telemetry) (reconcile.Result, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReconcileTelemetry", obj) + ret0, _ := ret[0].(reconcile.Result) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReconcileTelemetry indicates an expected call of ReconcileTelemetry. +func (mr *MockTelemetryFinalizerMockRecorder) ReconcileTelemetry(obj interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileTelemetry", reflect.TypeOf((*MockTelemetryFinalizer)(nil).ReconcileTelemetry), obj) +} + +// TelemetryFinalizerName mocks base method. +func (m *MockTelemetryFinalizer) TelemetryFinalizerName() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TelemetryFinalizerName") + ret0, _ := ret[0].(string) + return ret0 +} + +// TelemetryFinalizerName indicates an expected call of TelemetryFinalizerName. +func (mr *MockTelemetryFinalizerMockRecorder) TelemetryFinalizerName() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TelemetryFinalizerName", reflect.TypeOf((*MockTelemetryFinalizer)(nil).TelemetryFinalizerName)) +} + +// MockTelemetryReconcileLoop is a mock of TelemetryReconcileLoop interface. +type MockTelemetryReconcileLoop struct { + ctrl *gomock.Controller + recorder *MockTelemetryReconcileLoopMockRecorder +} + +// MockTelemetryReconcileLoopMockRecorder is the mock recorder for MockTelemetryReconcileLoop. +type MockTelemetryReconcileLoopMockRecorder struct { + mock *MockTelemetryReconcileLoop +} + +// NewMockTelemetryReconcileLoop creates a new mock instance. +func NewMockTelemetryReconcileLoop(ctrl *gomock.Controller) *MockTelemetryReconcileLoop { + mock := &MockTelemetryReconcileLoop{ctrl: ctrl} + mock.recorder = &MockTelemetryReconcileLoopMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryReconcileLoop) EXPECT() *MockTelemetryReconcileLoopMockRecorder { + return m.recorder +} + +// RunTelemetryReconciler mocks base method. +func (m *MockTelemetryReconcileLoop) RunTelemetryReconciler(ctx context.Context, rec controller.TelemetryReconciler, predicates ...predicate.Predicate) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, rec} + for _, a := range predicates { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RunTelemetryReconciler", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// RunTelemetryReconciler indicates an expected call of RunTelemetryReconciler. +func (mr *MockTelemetryReconcileLoopMockRecorder) RunTelemetryReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, rec}, predicates...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTelemetryReconciler", reflect.TypeOf((*MockTelemetryReconcileLoop)(nil).RunTelemetryReconciler), varargs...) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/multicluster_reconcilers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/multicluster_reconcilers.go new file mode 100644 index 0000000..481923d --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/multicluster_reconcilers.go @@ -0,0 +1,90 @@ +// Code generated by skv2. DO NOT EDIT. + +//go:generate mockgen -source ./multicluster_reconcilers.go -destination mocks/multicluster_reconcilers.go + +// Definitions for the multicluster Kubernetes Controllers +package controller + +import ( + "context" + + telemetry_istio_io_v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + + "github.com/pkg/errors" + "github.com/solo-io/skv2/pkg/ezkube" + "github.com/solo-io/skv2/pkg/multicluster" + mc_reconcile "github.com/solo-io/skv2/pkg/multicluster/reconcile" + "github.com/solo-io/skv2/pkg/reconcile" + "sigs.k8s.io/controller-runtime/pkg/predicate" +) + +// Reconcile Upsert events for the Telemetry Resource across clusters. +// implemented by the user +type MulticlusterTelemetryReconciler interface { + ReconcileTelemetry(clusterName string, obj *telemetry_istio_io_v1alpha1.Telemetry) (reconcile.Result, error) +} + +// Reconcile deletion events for the Telemetry Resource across clusters. +// Deletion receives a reconcile.Request as we cannot guarantee the last state of the object +// before being deleted. +// implemented by the user +type MulticlusterTelemetryDeletionReconciler interface { + ReconcileTelemetryDeletion(clusterName string, req reconcile.Request) error +} + +type MulticlusterTelemetryReconcilerFuncs struct { + OnReconcileTelemetry func(clusterName string, obj *telemetry_istio_io_v1alpha1.Telemetry) (reconcile.Result, error) + OnReconcileTelemetryDeletion func(clusterName string, req reconcile.Request) error +} + +func (f *MulticlusterTelemetryReconcilerFuncs) ReconcileTelemetry(clusterName string, obj *telemetry_istio_io_v1alpha1.Telemetry) (reconcile.Result, error) { + if f.OnReconcileTelemetry == nil { + return reconcile.Result{}, nil + } + return f.OnReconcileTelemetry(clusterName, obj) +} + +func (f *MulticlusterTelemetryReconcilerFuncs) ReconcileTelemetryDeletion(clusterName string, req reconcile.Request) error { + if f.OnReconcileTelemetryDeletion == nil { + return nil + } + return f.OnReconcileTelemetryDeletion(clusterName, req) +} + +type MulticlusterTelemetryReconcileLoop interface { + // AddMulticlusterTelemetryReconciler adds a MulticlusterTelemetryReconciler to the MulticlusterTelemetryReconcileLoop. + AddMulticlusterTelemetryReconciler(ctx context.Context, rec MulticlusterTelemetryReconciler, predicates ...predicate.Predicate) +} + +type multiclusterTelemetryReconcileLoop struct { + loop multicluster.Loop +} + +func (m *multiclusterTelemetryReconcileLoop) AddMulticlusterTelemetryReconciler(ctx context.Context, rec MulticlusterTelemetryReconciler, predicates ...predicate.Predicate) { + genericReconciler := genericTelemetryMulticlusterReconciler{reconciler: rec} + + m.loop.AddReconciler(ctx, genericReconciler, predicates...) +} + +func NewMulticlusterTelemetryReconcileLoop(name string, cw multicluster.ClusterWatcher, options reconcile.Options) MulticlusterTelemetryReconcileLoop { + return &multiclusterTelemetryReconcileLoop{loop: mc_reconcile.NewLoop(name, cw, &telemetry_istio_io_v1alpha1.Telemetry{}, options)} +} + +type genericTelemetryMulticlusterReconciler struct { + reconciler MulticlusterTelemetryReconciler +} + +func (g genericTelemetryMulticlusterReconciler) ReconcileDeletion(cluster string, req reconcile.Request) error { + if deletionReconciler, ok := g.reconciler.(MulticlusterTelemetryDeletionReconciler); ok { + return deletionReconciler.ReconcileTelemetryDeletion(cluster, req) + } + return nil +} + +func (g genericTelemetryMulticlusterReconciler) Reconcile(cluster string, object ezkube.Object) (reconcile.Result, error) { + obj, ok := object.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return reconcile.Result{}, errors.Errorf("internal error: Telemetry handler received event for %T", object) + } + return g.reconciler.ReconcileTelemetry(cluster, obj) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/reconcilers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/reconcilers.go new file mode 100644 index 0000000..ec7db67 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/controller/reconcilers.go @@ -0,0 +1,135 @@ +// Code generated by skv2. DO NOT EDIT. + +//go:generate mockgen -source ./reconcilers.go -destination mocks/reconcilers.go + +// Definitions for the Kubernetes Controllers +package controller + +import ( + "context" + + telemetry_istio_io_v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + + "github.com/pkg/errors" + "github.com/solo-io/skv2/pkg/ezkube" + "github.com/solo-io/skv2/pkg/reconcile" + "sigs.k8s.io/controller-runtime/pkg/manager" + "sigs.k8s.io/controller-runtime/pkg/predicate" +) + +// Reconcile Upsert events for the Telemetry Resource. +// implemented by the user +type TelemetryReconciler interface { + ReconcileTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) (reconcile.Result, error) +} + +// Reconcile deletion events for the Telemetry Resource. +// Deletion receives a reconcile.Request as we cannot guarantee the last state of the object +// before being deleted. +// implemented by the user +type TelemetryDeletionReconciler interface { + ReconcileTelemetryDeletion(req reconcile.Request) error +} + +type TelemetryReconcilerFuncs struct { + OnReconcileTelemetry func(obj *telemetry_istio_io_v1alpha1.Telemetry) (reconcile.Result, error) + OnReconcileTelemetryDeletion func(req reconcile.Request) error +} + +func (f *TelemetryReconcilerFuncs) ReconcileTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) (reconcile.Result, error) { + if f.OnReconcileTelemetry == nil { + return reconcile.Result{}, nil + } + return f.OnReconcileTelemetry(obj) +} + +func (f *TelemetryReconcilerFuncs) ReconcileTelemetryDeletion(req reconcile.Request) error { + if f.OnReconcileTelemetryDeletion == nil { + return nil + } + return f.OnReconcileTelemetryDeletion(req) +} + +// Reconcile and finalize the Telemetry Resource +// implemented by the user +type TelemetryFinalizer interface { + TelemetryReconciler + + // name of the finalizer used by this handler. + // finalizer names should be unique for a single task + TelemetryFinalizerName() string + + // finalize the object before it is deleted. + // Watchers created with a finalizing handler will a + FinalizeTelemetry(obj *telemetry_istio_io_v1alpha1.Telemetry) error +} + +type TelemetryReconcileLoop interface { + RunTelemetryReconciler(ctx context.Context, rec TelemetryReconciler, predicates ...predicate.Predicate) error +} + +type telemetryReconcileLoop struct { + loop reconcile.Loop +} + +func NewTelemetryReconcileLoop(name string, mgr manager.Manager, options reconcile.Options) TelemetryReconcileLoop { + return &telemetryReconcileLoop{ + // empty cluster indicates this reconciler is built for the local cluster + loop: reconcile.NewLoop(name, "", mgr, &telemetry_istio_io_v1alpha1.Telemetry{}, options), + } +} + +func (c *telemetryReconcileLoop) RunTelemetryReconciler(ctx context.Context, reconciler TelemetryReconciler, predicates ...predicate.Predicate) error { + genericReconciler := genericTelemetryReconciler{ + reconciler: reconciler, + } + + var reconcilerWrapper reconcile.Reconciler + if finalizingReconciler, ok := reconciler.(TelemetryFinalizer); ok { + reconcilerWrapper = genericTelemetryFinalizer{ + genericTelemetryReconciler: genericReconciler, + finalizingReconciler: finalizingReconciler, + } + } else { + reconcilerWrapper = genericReconciler + } + return c.loop.RunReconciler(ctx, reconcilerWrapper, predicates...) +} + +// genericTelemetryHandler implements a generic reconcile.Reconciler +type genericTelemetryReconciler struct { + reconciler TelemetryReconciler +} + +func (r genericTelemetryReconciler) Reconcile(object ezkube.Object) (reconcile.Result, error) { + obj, ok := object.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return reconcile.Result{}, errors.Errorf("internal error: Telemetry handler received event for %T", object) + } + return r.reconciler.ReconcileTelemetry(obj) +} + +func (r genericTelemetryReconciler) ReconcileDeletion(request reconcile.Request) error { + if deletionReconciler, ok := r.reconciler.(TelemetryDeletionReconciler); ok { + return deletionReconciler.ReconcileTelemetryDeletion(request) + } + return nil +} + +// genericTelemetryFinalizer implements a generic reconcile.FinalizingReconciler +type genericTelemetryFinalizer struct { + genericTelemetryReconciler + finalizingReconciler TelemetryFinalizer +} + +func (r genericTelemetryFinalizer) FinalizerName() string { + return r.finalizingReconciler.TelemetryFinalizerName() +} + +func (r genericTelemetryFinalizer) Finalize(object ezkube.Object) error { + obj, ok := object.(*telemetry_istio_io_v1alpha1.Telemetry) + if !ok { + return errors.Errorf("internal error: Telemetry handler received event for %T", object) + } + return r.finalizingReconciler.FinalizeTelemetry(obj) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/mocks/clients.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/mocks/clients.go new file mode 100644 index 0000000..c3e90ab --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/mocks/clients.go @@ -0,0 +1,594 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./clients.go + +// Package mock_v1alpha1 is a generated GoMock package. +package mock_v1alpha1 + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + v1alpha1 "github.com/solo-io/external-apis/pkg/api/istio/telemetry.istio.io/v1alpha1" + v1alpha10 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + client "sigs.k8s.io/controller-runtime/pkg/client" +) + +// MockMulticlusterClientset is a mock of MulticlusterClientset interface. +type MockMulticlusterClientset struct { + ctrl *gomock.Controller + recorder *MockMulticlusterClientsetMockRecorder +} + +// MockMulticlusterClientsetMockRecorder is the mock recorder for MockMulticlusterClientset. +type MockMulticlusterClientsetMockRecorder struct { + mock *MockMulticlusterClientset +} + +// NewMockMulticlusterClientset creates a new mock instance. +func NewMockMulticlusterClientset(ctrl *gomock.Controller) *MockMulticlusterClientset { + mock := &MockMulticlusterClientset{ctrl: ctrl} + mock.recorder = &MockMulticlusterClientsetMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMulticlusterClientset) EXPECT() *MockMulticlusterClientsetMockRecorder { + return m.recorder +} + +// Cluster mocks base method. +func (m *MockMulticlusterClientset) Cluster(cluster string) (v1alpha1.Clientset, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Cluster", cluster) + ret0, _ := ret[0].(v1alpha1.Clientset) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Cluster indicates an expected call of Cluster. +func (mr *MockMulticlusterClientsetMockRecorder) Cluster(cluster interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cluster", reflect.TypeOf((*MockMulticlusterClientset)(nil).Cluster), cluster) +} + +// MockClientset is a mock of Clientset interface. +type MockClientset struct { + ctrl *gomock.Controller + recorder *MockClientsetMockRecorder +} + +// MockClientsetMockRecorder is the mock recorder for MockClientset. +type MockClientsetMockRecorder struct { + mock *MockClientset +} + +// NewMockClientset creates a new mock instance. +func NewMockClientset(ctrl *gomock.Controller) *MockClientset { + mock := &MockClientset{ctrl: ctrl} + mock.recorder = &MockClientsetMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClientset) EXPECT() *MockClientsetMockRecorder { + return m.recorder +} + +// Telemetries mocks base method. +func (m *MockClientset) Telemetries() v1alpha1.TelemetryClient { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Telemetries") + ret0, _ := ret[0].(v1alpha1.TelemetryClient) + return ret0 +} + +// Telemetries indicates an expected call of Telemetries. +func (mr *MockClientsetMockRecorder) Telemetries() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Telemetries", reflect.TypeOf((*MockClientset)(nil).Telemetries)) +} + +// MockTelemetryReader is a mock of TelemetryReader interface. +type MockTelemetryReader struct { + ctrl *gomock.Controller + recorder *MockTelemetryReaderMockRecorder +} + +// MockTelemetryReaderMockRecorder is the mock recorder for MockTelemetryReader. +type MockTelemetryReaderMockRecorder struct { + mock *MockTelemetryReader +} + +// NewMockTelemetryReader creates a new mock instance. +func NewMockTelemetryReader(ctrl *gomock.Controller) *MockTelemetryReader { + mock := &MockTelemetryReader{ctrl: ctrl} + mock.recorder = &MockTelemetryReaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryReader) EXPECT() *MockTelemetryReaderMockRecorder { + return m.recorder +} + +// GetTelemetry mocks base method. +func (m *MockTelemetryReader) GetTelemetry(ctx context.Context, key client.ObjectKey) (*v1alpha10.Telemetry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTelemetry", ctx, key) + ret0, _ := ret[0].(*v1alpha10.Telemetry) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTelemetry indicates an expected call of GetTelemetry. +func (mr *MockTelemetryReaderMockRecorder) GetTelemetry(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetry", reflect.TypeOf((*MockTelemetryReader)(nil).GetTelemetry), ctx, key) +} + +// ListTelemetry mocks base method. +func (m *MockTelemetryReader) ListTelemetry(ctx context.Context, opts ...client.ListOption) (*v1alpha10.TelemetryList, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTelemetry", varargs...) + ret0, _ := ret[0].(*v1alpha10.TelemetryList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTelemetry indicates an expected call of ListTelemetry. +func (mr *MockTelemetryReaderMockRecorder) ListTelemetry(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTelemetry", reflect.TypeOf((*MockTelemetryReader)(nil).ListTelemetry), varargs...) +} + +// MockTelemetryWriter is a mock of TelemetryWriter interface. +type MockTelemetryWriter struct { + ctrl *gomock.Controller + recorder *MockTelemetryWriterMockRecorder +} + +// MockTelemetryWriterMockRecorder is the mock recorder for MockTelemetryWriter. +type MockTelemetryWriterMockRecorder struct { + mock *MockTelemetryWriter +} + +// NewMockTelemetryWriter creates a new mock instance. +func NewMockTelemetryWriter(ctrl *gomock.Controller) *MockTelemetryWriter { + mock := &MockTelemetryWriter{ctrl: ctrl} + mock.recorder = &MockTelemetryWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryWriter) EXPECT() *MockTelemetryWriterMockRecorder { + return m.recorder +} + +// CreateTelemetry mocks base method. +func (m *MockTelemetryWriter) CreateTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, opts ...client.CreateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateTelemetry indicates an expected call of CreateTelemetry. +func (mr *MockTelemetryWriterMockRecorder) CreateTelemetry(ctx, obj interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTelemetry", reflect.TypeOf((*MockTelemetryWriter)(nil).CreateTelemetry), varargs...) +} + +// DeleteAllOfTelemetry mocks base method. +func (m *MockTelemetryWriter) DeleteAllOfTelemetry(ctx context.Context, opts ...client.DeleteAllOfOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAllOfTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteAllOfTelemetry indicates an expected call of DeleteAllOfTelemetry. +func (mr *MockTelemetryWriterMockRecorder) DeleteAllOfTelemetry(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfTelemetry", reflect.TypeOf((*MockTelemetryWriter)(nil).DeleteAllOfTelemetry), varargs...) +} + +// DeleteTelemetry mocks base method. +func (m *MockTelemetryWriter) DeleteTelemetry(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteTelemetry indicates an expected call of DeleteTelemetry. +func (mr *MockTelemetryWriterMockRecorder) DeleteTelemetry(ctx, key interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTelemetry", reflect.TypeOf((*MockTelemetryWriter)(nil).DeleteTelemetry), varargs...) +} + +// PatchTelemetry mocks base method. +func (m *MockTelemetryWriter) PatchTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, patch client.Patch, opts ...client.PatchOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj, patch} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PatchTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// PatchTelemetry indicates an expected call of PatchTelemetry. +func (mr *MockTelemetryWriterMockRecorder) PatchTelemetry(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj, patch}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTelemetry", reflect.TypeOf((*MockTelemetryWriter)(nil).PatchTelemetry), varargs...) +} + +// UpdateTelemetry mocks base method. +func (m *MockTelemetryWriter) UpdateTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, opts ...client.UpdateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTelemetry indicates an expected call of UpdateTelemetry. +func (mr *MockTelemetryWriterMockRecorder) UpdateTelemetry(ctx, obj interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTelemetry", reflect.TypeOf((*MockTelemetryWriter)(nil).UpdateTelemetry), varargs...) +} + +// UpsertTelemetry mocks base method. +func (m *MockTelemetryWriter) UpsertTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, transitionFuncs ...v1alpha1.TelemetryTransitionFunction) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range transitionFuncs { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpsertTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertTelemetry indicates an expected call of UpsertTelemetry. +func (mr *MockTelemetryWriterMockRecorder) UpsertTelemetry(ctx, obj interface{}, transitionFuncs ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, transitionFuncs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTelemetry", reflect.TypeOf((*MockTelemetryWriter)(nil).UpsertTelemetry), varargs...) +} + +// MockTelemetryStatusWriter is a mock of TelemetryStatusWriter interface. +type MockTelemetryStatusWriter struct { + ctrl *gomock.Controller + recorder *MockTelemetryStatusWriterMockRecorder +} + +// MockTelemetryStatusWriterMockRecorder is the mock recorder for MockTelemetryStatusWriter. +type MockTelemetryStatusWriterMockRecorder struct { + mock *MockTelemetryStatusWriter +} + +// NewMockTelemetryStatusWriter creates a new mock instance. +func NewMockTelemetryStatusWriter(ctrl *gomock.Controller) *MockTelemetryStatusWriter { + mock := &MockTelemetryStatusWriter{ctrl: ctrl} + mock.recorder = &MockTelemetryStatusWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryStatusWriter) EXPECT() *MockTelemetryStatusWriterMockRecorder { + return m.recorder +} + +// PatchTelemetryStatus mocks base method. +func (m *MockTelemetryStatusWriter) PatchTelemetryStatus(ctx context.Context, obj *v1alpha10.Telemetry, patch client.Patch, opts ...client.SubResourcePatchOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj, patch} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PatchTelemetryStatus", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// PatchTelemetryStatus indicates an expected call of PatchTelemetryStatus. +func (mr *MockTelemetryStatusWriterMockRecorder) PatchTelemetryStatus(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj, patch}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTelemetryStatus", reflect.TypeOf((*MockTelemetryStatusWriter)(nil).PatchTelemetryStatus), varargs...) +} + +// UpdateTelemetryStatus mocks base method. +func (m *MockTelemetryStatusWriter) UpdateTelemetryStatus(ctx context.Context, obj *v1alpha10.Telemetry, opts ...client.SubResourceUpdateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTelemetryStatus", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTelemetryStatus indicates an expected call of UpdateTelemetryStatus. +func (mr *MockTelemetryStatusWriterMockRecorder) UpdateTelemetryStatus(ctx, obj interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTelemetryStatus", reflect.TypeOf((*MockTelemetryStatusWriter)(nil).UpdateTelemetryStatus), varargs...) +} + +// MockTelemetryClient is a mock of TelemetryClient interface. +type MockTelemetryClient struct { + ctrl *gomock.Controller + recorder *MockTelemetryClientMockRecorder +} + +// MockTelemetryClientMockRecorder is the mock recorder for MockTelemetryClient. +type MockTelemetryClientMockRecorder struct { + mock *MockTelemetryClient +} + +// NewMockTelemetryClient creates a new mock instance. +func NewMockTelemetryClient(ctrl *gomock.Controller) *MockTelemetryClient { + mock := &MockTelemetryClient{ctrl: ctrl} + mock.recorder = &MockTelemetryClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetryClient) EXPECT() *MockTelemetryClientMockRecorder { + return m.recorder +} + +// CreateTelemetry mocks base method. +func (m *MockTelemetryClient) CreateTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, opts ...client.CreateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// CreateTelemetry indicates an expected call of CreateTelemetry. +func (mr *MockTelemetryClientMockRecorder) CreateTelemetry(ctx, obj interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).CreateTelemetry), varargs...) +} + +// DeleteAllOfTelemetry mocks base method. +func (m *MockTelemetryClient) DeleteAllOfTelemetry(ctx context.Context, opts ...client.DeleteAllOfOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAllOfTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteAllOfTelemetry indicates an expected call of DeleteAllOfTelemetry. +func (mr *MockTelemetryClientMockRecorder) DeleteAllOfTelemetry(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).DeleteAllOfTelemetry), varargs...) +} + +// DeleteTelemetry mocks base method. +func (m *MockTelemetryClient) DeleteTelemetry(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, key} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteTelemetry indicates an expected call of DeleteTelemetry. +func (mr *MockTelemetryClientMockRecorder) DeleteTelemetry(ctx, key interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, key}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).DeleteTelemetry), varargs...) +} + +// GetTelemetry mocks base method. +func (m *MockTelemetryClient) GetTelemetry(ctx context.Context, key client.ObjectKey) (*v1alpha10.Telemetry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTelemetry", ctx, key) + ret0, _ := ret[0].(*v1alpha10.Telemetry) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTelemetry indicates an expected call of GetTelemetry. +func (mr *MockTelemetryClientMockRecorder) GetTelemetry(ctx, key interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).GetTelemetry), ctx, key) +} + +// ListTelemetry mocks base method. +func (m *MockTelemetryClient) ListTelemetry(ctx context.Context, opts ...client.ListOption) (*v1alpha10.TelemetryList, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTelemetry", varargs...) + ret0, _ := ret[0].(*v1alpha10.TelemetryList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTelemetry indicates an expected call of ListTelemetry. +func (mr *MockTelemetryClientMockRecorder) ListTelemetry(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).ListTelemetry), varargs...) +} + +// PatchTelemetry mocks base method. +func (m *MockTelemetryClient) PatchTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, patch client.Patch, opts ...client.PatchOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj, patch} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PatchTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// PatchTelemetry indicates an expected call of PatchTelemetry. +func (mr *MockTelemetryClientMockRecorder) PatchTelemetry(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj, patch}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).PatchTelemetry), varargs...) +} + +// PatchTelemetryStatus mocks base method. +func (m *MockTelemetryClient) PatchTelemetryStatus(ctx context.Context, obj *v1alpha10.Telemetry, patch client.Patch, opts ...client.SubResourcePatchOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj, patch} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PatchTelemetryStatus", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// PatchTelemetryStatus indicates an expected call of PatchTelemetryStatus. +func (mr *MockTelemetryClientMockRecorder) PatchTelemetryStatus(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj, patch}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTelemetryStatus", reflect.TypeOf((*MockTelemetryClient)(nil).PatchTelemetryStatus), varargs...) +} + +// UpdateTelemetry mocks base method. +func (m *MockTelemetryClient) UpdateTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, opts ...client.UpdateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTelemetry indicates an expected call of UpdateTelemetry. +func (mr *MockTelemetryClientMockRecorder) UpdateTelemetry(ctx, obj interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).UpdateTelemetry), varargs...) +} + +// UpdateTelemetryStatus mocks base method. +func (m *MockTelemetryClient) UpdateTelemetryStatus(ctx context.Context, obj *v1alpha10.Telemetry, opts ...client.SubResourceUpdateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTelemetryStatus", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTelemetryStatus indicates an expected call of UpdateTelemetryStatus. +func (mr *MockTelemetryClientMockRecorder) UpdateTelemetryStatus(ctx, obj interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTelemetryStatus", reflect.TypeOf((*MockTelemetryClient)(nil).UpdateTelemetryStatus), varargs...) +} + +// UpsertTelemetry mocks base method. +func (m *MockTelemetryClient) UpsertTelemetry(ctx context.Context, obj *v1alpha10.Telemetry, transitionFuncs ...v1alpha1.TelemetryTransitionFunction) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, obj} + for _, a := range transitionFuncs { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpsertTelemetry", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertTelemetry indicates an expected call of UpsertTelemetry. +func (mr *MockTelemetryClientMockRecorder) UpsertTelemetry(ctx, obj interface{}, transitionFuncs ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, obj}, transitionFuncs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTelemetry", reflect.TypeOf((*MockTelemetryClient)(nil).UpsertTelemetry), varargs...) +} + +// MockMulticlusterTelemetryClient is a mock of MulticlusterTelemetryClient interface. +type MockMulticlusterTelemetryClient struct { + ctrl *gomock.Controller + recorder *MockMulticlusterTelemetryClientMockRecorder +} + +// MockMulticlusterTelemetryClientMockRecorder is the mock recorder for MockMulticlusterTelemetryClient. +type MockMulticlusterTelemetryClientMockRecorder struct { + mock *MockMulticlusterTelemetryClient +} + +// NewMockMulticlusterTelemetryClient creates a new mock instance. +func NewMockMulticlusterTelemetryClient(ctrl *gomock.Controller) *MockMulticlusterTelemetryClient { + mock := &MockMulticlusterTelemetryClient{ctrl: ctrl} + mock.recorder = &MockMulticlusterTelemetryClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMulticlusterTelemetryClient) EXPECT() *MockMulticlusterTelemetryClientMockRecorder { + return m.recorder +} + +// Cluster mocks base method. +func (m *MockMulticlusterTelemetryClient) Cluster(cluster string) (v1alpha1.TelemetryClient, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Cluster", cluster) + ret0, _ := ret[0].(v1alpha1.TelemetryClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Cluster indicates an expected call of Cluster. +func (mr *MockMulticlusterTelemetryClientMockRecorder) Cluster(cluster interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cluster", reflect.TypeOf((*MockMulticlusterTelemetryClient)(nil).Cluster), cluster) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/providers/client_providers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/providers/client_providers.go new file mode 100644 index 0000000..cd2b6f7 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/providers/client_providers.go @@ -0,0 +1,46 @@ +// Code generated by skv2. DO NOT EDIT. + +package v1alpha1 + +import ( + telemetry_istio_io_v1alpha1 "github.com/solo-io/external-apis/pkg/api/istio/telemetry.istio.io/v1alpha1" + + "k8s.io/client-go/rest" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +/* + The intention of these providers are to be used for Mocking. + They expose the Clients as interfaces, as well as factories to provide mocked versions + of the clients when they require building within a component. + + See package `github.com/solo-io/skv2/pkg/multicluster/register` for example +*/ + +// Provider for TelemetryClient from Clientset +func TelemetryClientFromClientsetProvider(clients telemetry_istio_io_v1alpha1.Clientset) telemetry_istio_io_v1alpha1.TelemetryClient { + return clients.Telemetries() +} + +// Provider for Telemetry Client from Client +func TelemetryClientProvider(client client.Client) telemetry_istio_io_v1alpha1.TelemetryClient { + return telemetry_istio_io_v1alpha1.NewTelemetryClient(client) +} + +type TelemetryClientFactory func(client client.Client) telemetry_istio_io_v1alpha1.TelemetryClient + +func TelemetryClientFactoryProvider() TelemetryClientFactory { + return TelemetryClientProvider +} + +type TelemetryClientFromConfigFactory func(cfg *rest.Config) (telemetry_istio_io_v1alpha1.TelemetryClient, error) + +func TelemetryClientFromConfigFactoryProvider() TelemetryClientFromConfigFactory { + return func(cfg *rest.Config) (telemetry_istio_io_v1alpha1.TelemetryClient, error) { + clients, err := telemetry_istio_io_v1alpha1.NewClientsetFromConfig(cfg) + if err != nil { + return nil, err + } + return clients.Telemetries(), nil + } +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/sets/mocks/sets.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/sets/mocks/sets.go new file mode 100644 index 0000000..de0034d --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/sets/mocks/sets.go @@ -0,0 +1,272 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./sets.go + +// Package mock_v1alpha1sets is a generated GoMock package. +package mock_v1alpha1sets + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + v1alpha1sets "github.com/solo-io/external-apis/pkg/api/istio/telemetry.istio.io/v1alpha1/sets" + sets "github.com/solo-io/skv2/contrib/pkg/sets" + ezkube "github.com/solo-io/skv2/pkg/ezkube" + v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + sets0 "k8s.io/apimachinery/pkg/util/sets" +) + +// MockTelemetrySet is a mock of TelemetrySet interface. +type MockTelemetrySet struct { + ctrl *gomock.Controller + recorder *MockTelemetrySetMockRecorder +} + +// MockTelemetrySetMockRecorder is the mock recorder for MockTelemetrySet. +type MockTelemetrySetMockRecorder struct { + mock *MockTelemetrySet +} + +// NewMockTelemetrySet creates a new mock instance. +func NewMockTelemetrySet(ctrl *gomock.Controller) *MockTelemetrySet { + mock := &MockTelemetrySet{ctrl: ctrl} + mock.recorder = &MockTelemetrySetMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTelemetrySet) EXPECT() *MockTelemetrySetMockRecorder { + return m.recorder +} + +// Clone mocks base method. +func (m *MockTelemetrySet) Clone() v1alpha1sets.TelemetrySet { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Clone") + ret0, _ := ret[0].(v1alpha1sets.TelemetrySet) + return ret0 +} + +// Clone indicates an expected call of Clone. +func (mr *MockTelemetrySetMockRecorder) Clone() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockTelemetrySet)(nil).Clone)) +} + +// Delete mocks base method. +func (m *MockTelemetrySet) Delete(telemetry ezkube.ResourceId) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Delete", telemetry) +} + +// Delete indicates an expected call of Delete. +func (mr *MockTelemetrySetMockRecorder) Delete(telemetry interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockTelemetrySet)(nil).Delete), telemetry) +} + +// Delta mocks base method. +func (m *MockTelemetrySet) Delta(newSet v1alpha1sets.TelemetrySet) sets.ResourceDelta { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delta", newSet) + ret0, _ := ret[0].(sets.ResourceDelta) + return ret0 +} + +// Delta indicates an expected call of Delta. +func (mr *MockTelemetrySetMockRecorder) Delta(newSet interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delta", reflect.TypeOf((*MockTelemetrySet)(nil).Delta), newSet) +} + +// Difference mocks base method. +func (m *MockTelemetrySet) Difference(set v1alpha1sets.TelemetrySet) v1alpha1sets.TelemetrySet { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Difference", set) + ret0, _ := ret[0].(v1alpha1sets.TelemetrySet) + return ret0 +} + +// Difference indicates an expected call of Difference. +func (mr *MockTelemetrySetMockRecorder) Difference(set interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Difference", reflect.TypeOf((*MockTelemetrySet)(nil).Difference), set) +} + +// Equal mocks base method. +func (m *MockTelemetrySet) Equal(telemetrySet v1alpha1sets.TelemetrySet) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Equal", telemetrySet) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Equal indicates an expected call of Equal. +func (mr *MockTelemetrySetMockRecorder) Equal(telemetrySet interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockTelemetrySet)(nil).Equal), telemetrySet) +} + +// Find mocks base method. +func (m *MockTelemetrySet) Find(id ezkube.ResourceId) (*v1alpha1.Telemetry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Find", id) + ret0, _ := ret[0].(*v1alpha1.Telemetry) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Find indicates an expected call of Find. +func (mr *MockTelemetrySetMockRecorder) Find(id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockTelemetrySet)(nil).Find), id) +} + +// Generic mocks base method. +func (m *MockTelemetrySet) Generic() sets.ResourceSet { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Generic") + ret0, _ := ret[0].(sets.ResourceSet) + return ret0 +} + +// Generic indicates an expected call of Generic. +func (mr *MockTelemetrySetMockRecorder) Generic() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generic", reflect.TypeOf((*MockTelemetrySet)(nil).Generic)) +} + +// Has mocks base method. +func (m *MockTelemetrySet) Has(telemetry ezkube.ResourceId) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Has", telemetry) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Has indicates an expected call of Has. +func (mr *MockTelemetrySetMockRecorder) Has(telemetry interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockTelemetrySet)(nil).Has), telemetry) +} + +// Insert mocks base method. +func (m *MockTelemetrySet) Insert(telemetry ...*v1alpha1.Telemetry) { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range telemetry { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Insert", varargs...) +} + +// Insert indicates an expected call of Insert. +func (mr *MockTelemetrySetMockRecorder) Insert(telemetry ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockTelemetrySet)(nil).Insert), telemetry...) +} + +// Intersection mocks base method. +func (m *MockTelemetrySet) Intersection(set v1alpha1sets.TelemetrySet) v1alpha1sets.TelemetrySet { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Intersection", set) + ret0, _ := ret[0].(v1alpha1sets.TelemetrySet) + return ret0 +} + +// Intersection indicates an expected call of Intersection. +func (mr *MockTelemetrySetMockRecorder) Intersection(set interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Intersection", reflect.TypeOf((*MockTelemetrySet)(nil).Intersection), set) +} + +// Keys mocks base method. +func (m *MockTelemetrySet) Keys() sets0.String { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keys") + ret0, _ := ret[0].(sets0.String) + return ret0 +} + +// Keys indicates an expected call of Keys. +func (mr *MockTelemetrySetMockRecorder) Keys() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockTelemetrySet)(nil).Keys)) +} + +// Length mocks base method. +func (m *MockTelemetrySet) Length() int { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Length") + ret0, _ := ret[0].(int) + return ret0 +} + +// Length indicates an expected call of Length. +func (mr *MockTelemetrySetMockRecorder) Length() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Length", reflect.TypeOf((*MockTelemetrySet)(nil).Length)) +} + +// List mocks base method. +func (m *MockTelemetrySet) List(filterResource ...func(*v1alpha1.Telemetry) bool) []*v1alpha1.Telemetry { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range filterResource { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*v1alpha1.Telemetry) + return ret0 +} + +// List indicates an expected call of List. +func (mr *MockTelemetrySetMockRecorder) List(filterResource ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockTelemetrySet)(nil).List), filterResource...) +} + +// Map mocks base method. +func (m *MockTelemetrySet) Map() map[string]*v1alpha1.Telemetry { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Map") + ret0, _ := ret[0].(map[string]*v1alpha1.Telemetry) + return ret0 +} + +// Map indicates an expected call of Map. +func (mr *MockTelemetrySetMockRecorder) Map() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockTelemetrySet)(nil).Map)) +} + +// Union mocks base method. +func (m *MockTelemetrySet) Union(set v1alpha1sets.TelemetrySet) v1alpha1sets.TelemetrySet { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Union", set) + ret0, _ := ret[0].(v1alpha1sets.TelemetrySet) + return ret0 +} + +// Union indicates an expected call of Union. +func (mr *MockTelemetrySetMockRecorder) Union(set interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Union", reflect.TypeOf((*MockTelemetrySet)(nil).Union), set) +} + +// UnsortedList mocks base method. +func (m *MockTelemetrySet) UnsortedList(filterResource ...func(*v1alpha1.Telemetry) bool) []*v1alpha1.Telemetry { + m.ctrl.T.Helper() + varargs := []interface{}{} + for _, a := range filterResource { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnsortedList", varargs...) + ret0, _ := ret[0].([]*v1alpha1.Telemetry) + return ret0 +} + +// UnsortedList indicates an expected call of UnsortedList. +func (mr *MockTelemetrySetMockRecorder) UnsortedList(filterResource ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsortedList", reflect.TypeOf((*MockTelemetrySet)(nil).UnsortedList), filterResource...) +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/sets/sets.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/sets/sets.go new file mode 100644 index 0000000..79c4e12 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/sets/sets.go @@ -0,0 +1,235 @@ +// Code generated by skv2. DO NOT EDIT. + +//go:generate mockgen -source ./sets.go -destination mocks/sets.go + +package v1alpha1sets + +import ( + telemetry_istio_io_v1alpha1 "istio.io/client-go/pkg/apis/telemetry/v1alpha1" + + "github.com/rotisserie/eris" + sksets "github.com/solo-io/skv2/contrib/pkg/sets" + "github.com/solo-io/skv2/pkg/ezkube" + "k8s.io/apimachinery/pkg/util/sets" +) + +type TelemetrySet interface { + // Get the set stored keys + Keys() sets.String + // List of resources stored in the set. Pass an optional filter function to filter on the list. + List(filterResource ...func(*telemetry_istio_io_v1alpha1.Telemetry) bool) []*telemetry_istio_io_v1alpha1.Telemetry + // Unsorted list of resources stored in the set. Pass an optional filter function to filter on the list. + UnsortedList(filterResource ...func(*telemetry_istio_io_v1alpha1.Telemetry) bool) []*telemetry_istio_io_v1alpha1.Telemetry + // Return the Set as a map of key to resource. + Map() map[string]*telemetry_istio_io_v1alpha1.Telemetry + // Insert a resource into the set. + Insert(telemetry ...*telemetry_istio_io_v1alpha1.Telemetry) + // Compare the equality of the keys in two sets (not the resources themselves) + Equal(telemetrySet TelemetrySet) bool + // Check if the set contains a key matching the resource (not the resource itself) + Has(telemetry ezkube.ResourceId) bool + // Delete the key matching the resource + Delete(telemetry ezkube.ResourceId) + // Return the union with the provided set + Union(set TelemetrySet) TelemetrySet + // Return the difference with the provided set + Difference(set TelemetrySet) TelemetrySet + // Return the intersection with the provided set + Intersection(set TelemetrySet) TelemetrySet + // Find the resource with the given ID + Find(id ezkube.ResourceId) (*telemetry_istio_io_v1alpha1.Telemetry, error) + // Get the length of the set + Length() int + // returns the generic implementation of the set + Generic() sksets.ResourceSet + // returns the delta between this and and another TelemetrySet + Delta(newSet TelemetrySet) sksets.ResourceDelta + // Create a deep copy of the current TelemetrySet + Clone() TelemetrySet +} + +func makeGenericTelemetrySet(telemetryList []*telemetry_istio_io_v1alpha1.Telemetry) sksets.ResourceSet { + var genericResources []ezkube.ResourceId + for _, obj := range telemetryList { + genericResources = append(genericResources, obj) + } + return sksets.NewResourceSet(genericResources...) +} + +type telemetrySet struct { + set sksets.ResourceSet +} + +func NewTelemetrySet(telemetryList ...*telemetry_istio_io_v1alpha1.Telemetry) TelemetrySet { + return &telemetrySet{set: makeGenericTelemetrySet(telemetryList)} +} + +func NewTelemetrySetFromList(telemetryList *telemetry_istio_io_v1alpha1.TelemetryList) TelemetrySet { + list := make([]*telemetry_istio_io_v1alpha1.Telemetry, 0, len(telemetryList.Items)) + for idx := range telemetryList.Items { + list = append(list, telemetryList.Items[idx]) + } + return &telemetrySet{set: makeGenericTelemetrySet(list)} +} + +func (s *telemetrySet) Keys() sets.String { + if s == nil { + return sets.String{} + } + return s.Generic().Keys() +} + +func (s *telemetrySet) List(filterResource ...func(*telemetry_istio_io_v1alpha1.Telemetry) bool) []*telemetry_istio_io_v1alpha1.Telemetry { + if s == nil { + return nil + } + var genericFilters []func(ezkube.ResourceId) bool + for _, filter := range filterResource { + filter := filter + genericFilters = append(genericFilters, func(obj ezkube.ResourceId) bool { + return filter(obj.(*telemetry_istio_io_v1alpha1.Telemetry)) + }) + } + + objs := s.Generic().List(genericFilters...) + telemetryList := make([]*telemetry_istio_io_v1alpha1.Telemetry, 0, len(objs)) + for _, obj := range objs { + telemetryList = append(telemetryList, obj.(*telemetry_istio_io_v1alpha1.Telemetry)) + } + return telemetryList +} + +func (s *telemetrySet) UnsortedList(filterResource ...func(*telemetry_istio_io_v1alpha1.Telemetry) bool) []*telemetry_istio_io_v1alpha1.Telemetry { + if s == nil { + return nil + } + var genericFilters []func(ezkube.ResourceId) bool + for _, filter := range filterResource { + filter := filter + genericFilters = append(genericFilters, func(obj ezkube.ResourceId) bool { + return filter(obj.(*telemetry_istio_io_v1alpha1.Telemetry)) + }) + } + + var telemetryList []*telemetry_istio_io_v1alpha1.Telemetry + for _, obj := range s.Generic().UnsortedList(genericFilters...) { + telemetryList = append(telemetryList, obj.(*telemetry_istio_io_v1alpha1.Telemetry)) + } + return telemetryList +} + +func (s *telemetrySet) Map() map[string]*telemetry_istio_io_v1alpha1.Telemetry { + if s == nil { + return nil + } + + newMap := map[string]*telemetry_istio_io_v1alpha1.Telemetry{} + for k, v := range s.Generic().Map() { + newMap[k] = v.(*telemetry_istio_io_v1alpha1.Telemetry) + } + return newMap +} + +func (s *telemetrySet) Insert( + telemetryList ...*telemetry_istio_io_v1alpha1.Telemetry, +) { + if s == nil { + panic("cannot insert into nil set") + } + + for _, obj := range telemetryList { + s.Generic().Insert(obj) + } +} + +func (s *telemetrySet) Has(telemetry ezkube.ResourceId) bool { + if s == nil { + return false + } + return s.Generic().Has(telemetry) +} + +func (s *telemetrySet) Equal( + telemetrySet TelemetrySet, +) bool { + if s == nil { + return telemetrySet == nil + } + return s.Generic().Equal(telemetrySet.Generic()) +} + +func (s *telemetrySet) Delete(Telemetry ezkube.ResourceId) { + if s == nil { + return + } + s.Generic().Delete(Telemetry) +} + +func (s *telemetrySet) Union(set TelemetrySet) TelemetrySet { + if s == nil { + return set + } + return NewTelemetrySet(append(s.List(), set.List()...)...) +} + +func (s *telemetrySet) Difference(set TelemetrySet) TelemetrySet { + if s == nil { + return set + } + newSet := s.Generic().Difference(set.Generic()) + return &telemetrySet{set: newSet} +} + +func (s *telemetrySet) Intersection(set TelemetrySet) TelemetrySet { + if s == nil { + return nil + } + newSet := s.Generic().Intersection(set.Generic()) + var telemetryList []*telemetry_istio_io_v1alpha1.Telemetry + for _, obj := range newSet.List() { + telemetryList = append(telemetryList, obj.(*telemetry_istio_io_v1alpha1.Telemetry)) + } + return NewTelemetrySet(telemetryList...) +} + +func (s *telemetrySet) Find(id ezkube.ResourceId) (*telemetry_istio_io_v1alpha1.Telemetry, error) { + if s == nil { + return nil, eris.Errorf("empty set, cannot find Telemetry %v", sksets.Key(id)) + } + obj, err := s.Generic().Find(&telemetry_istio_io_v1alpha1.Telemetry{}, id) + if err != nil { + return nil, err + } + + return obj.(*telemetry_istio_io_v1alpha1.Telemetry), nil +} + +func (s *telemetrySet) Length() int { + if s == nil { + return 0 + } + return s.Generic().Length() +} + +func (s *telemetrySet) Generic() sksets.ResourceSet { + if s == nil { + return nil + } + return s.set +} + +func (s *telemetrySet) Delta(newSet TelemetrySet) sksets.ResourceDelta { + if s == nil { + return sksets.ResourceDelta{ + Inserted: newSet.Generic(), + } + } + return s.Generic().Delta(newSet.Generic()) +} + +func (s *telemetrySet) Clone() TelemetrySet { + if s == nil { + return nil + } + return &telemetrySet{set: sksets.NewResourceSet(s.Generic().Clone().List()...)} +} diff --git a/pkg/api/istio/telemetry.istio.io/v1alpha1/type_helpers.go b/pkg/api/istio/telemetry.istio.io/v1alpha1/type_helpers.go new file mode 100644 index 0000000..1277ab2 --- /dev/null +++ b/pkg/api/istio/telemetry.istio.io/v1alpha1/type_helpers.go @@ -0,0 +1,11 @@ +// Code generated by skv2. DO NOT EDIT. + +// Definitions for the Kubernetes types +package v1alpha1 + +import ( + . "istio.io/client-go/pkg/apis/telemetry/v1alpha1" +) + +// TelemetrySlice represents a slice of *Telemetry +type TelemetrySlice []*Telemetry