diff --git a/apis/management.cattle.io/v3/schema/schema.go b/apis/management.cattle.io/v3/schema/schema.go index 184093d7..12225f81 100644 --- a/apis/management.cattle.io/v3/schema/schema.go +++ b/apis/management.cattle.io/v3/schema/schema.go @@ -72,7 +72,8 @@ func clusterTypes(schemas *types.Schemas) *types.Schemas { AddMapperForType(&Version, v3.ClusterStatus{}, m.Drop{"appliedSpec"}, ). - MustImport(&Version, v3.Cluster{}) + MustImport(&Version, v3.Cluster{}). + MustImport(&Version, v3.ClusterEvent{}) } func authzTypes(schemas *types.Schemas) *types.Schemas { diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_event_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_event_controller.go new file mode 100644 index 00000000..d9a5cd02 --- /dev/null +++ b/apis/management.cattle.io/v3/zz_generated_cluster_event_controller.go @@ -0,0 +1,187 @@ +package v3 + +import ( + "context" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" +) + +var ( + ClusterEventGroupVersionKind = schema.GroupVersionKind{ + Version: "v3", + Group: "management.cattle.io", + Kind: "ClusterEvent", + } + ClusterEventResource = metav1.APIResource{ + Name: "clusterevents", + SingularName: "clusterevent", + Namespaced: false, + Kind: ClusterEventGroupVersionKind.Kind, + } +) + +type ClusterEventList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ClusterEvent +} + +type ClusterEventHandlerFunc func(key string, obj *ClusterEvent) error + +type ClusterEventLister interface { + List(namespace string, selector labels.Selector) (ret []*ClusterEvent, err error) + Get(namespace, name string) (*ClusterEvent, error) +} + +type ClusterEventController interface { + Informer() cache.SharedIndexInformer + Lister() ClusterEventLister + AddHandler(handler ClusterEventHandlerFunc) + Enqueue(namespace, name string) + Sync(ctx context.Context) error + Start(ctx context.Context, threadiness int) error +} + +type ClusterEventInterface interface { + ObjectClient() *clientbase.ObjectClient + Create(*ClusterEvent) (*ClusterEvent, error) + Get(name string, opts metav1.GetOptions) (*ClusterEvent, error) + Update(*ClusterEvent) (*ClusterEvent, error) + Delete(name string, options *metav1.DeleteOptions) error + List(opts metav1.ListOptions) (*ClusterEventList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error + Controller() ClusterEventController +} + +type clusterEventLister struct { + controller *clusterEventController +} + +func (l *clusterEventLister) List(namespace string, selector labels.Selector) (ret []*ClusterEvent, err error) { + err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { + ret = append(ret, obj.(*ClusterEvent)) + }) + return +} + +func (l *clusterEventLister) Get(namespace, name string) (*ClusterEvent, error) { + obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(schema.GroupResource{ + Group: ClusterEventGroupVersionKind.Group, + Resource: "clusterEvent", + }, name) + } + return obj.(*ClusterEvent), nil +} + +type clusterEventController struct { + controller.GenericController +} + +func (c *clusterEventController) Lister() ClusterEventLister { + return &clusterEventLister{ + controller: c, + } +} + +func (c *clusterEventController) AddHandler(handler ClusterEventHandlerFunc) { + c.GenericController.AddHandler(func(key string) error { + obj, exists, err := c.Informer().GetStore().GetByKey(key) + if err != nil { + return err + } + if !exists { + return handler(key, nil) + } + return handler(key, obj.(*ClusterEvent)) + }) +} + +type clusterEventFactory struct { +} + +func (c clusterEventFactory) Object() runtime.Object { + return &ClusterEvent{} +} + +func (c clusterEventFactory) List() runtime.Object { + return &ClusterEventList{} +} + +func (s *clusterEventClient) Controller() ClusterEventController { + s.client.Lock() + defer s.client.Unlock() + + c, ok := s.client.clusterEventControllers[s.ns] + if ok { + return c + } + + genericController := controller.NewGenericController(ClusterEventGroupVersionKind.Kind+"Controller", + s.objectClient) + + c = &clusterEventController{ + GenericController: genericController, + } + + s.client.clusterEventControllers[s.ns] = c + s.client.starters = append(s.client.starters, c) + + return c +} + +type clusterEventClient struct { + client *Client + ns string + objectClient *clientbase.ObjectClient + controller ClusterEventController +} + +func (s *clusterEventClient) ObjectClient() *clientbase.ObjectClient { + return s.objectClient +} + +func (s *clusterEventClient) Create(o *ClusterEvent) (*ClusterEvent, error) { + obj, err := s.objectClient.Create(o) + return obj.(*ClusterEvent), err +} + +func (s *clusterEventClient) Get(name string, opts metav1.GetOptions) (*ClusterEvent, error) { + obj, err := s.objectClient.Get(name, opts) + return obj.(*ClusterEvent), err +} + +func (s *clusterEventClient) Update(o *ClusterEvent) (*ClusterEvent, error) { + obj, err := s.objectClient.Update(o.Name, o) + return obj.(*ClusterEvent), err +} + +func (s *clusterEventClient) Delete(name string, options *metav1.DeleteOptions) error { + return s.objectClient.Delete(name, options) +} + +func (s *clusterEventClient) List(opts metav1.ListOptions) (*ClusterEventList, error) { + obj, err := s.objectClient.List(opts) + return obj.(*ClusterEventList), err +} + +func (s *clusterEventClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return s.objectClient.Watch(opts) +} + +func (s *clusterEventClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { + return s.objectClient.DeleteCollection(deleteOpts, listOpts) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_event_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_event_lifecycle_adapter.go new file mode 100644 index 00000000..85b8b207 --- /dev/null +++ b/apis/management.cattle.io/v3/zz_generated_cluster_event_lifecycle_adapter.go @@ -0,0 +1,39 @@ +package v3 + +import ( + "github.com/rancher/norman/lifecycle" + "k8s.io/apimachinery/pkg/runtime" +) + +type ClusterEventLifecycle interface { + Create(obj *ClusterEvent) error + Remove(obj *ClusterEvent) error + Updated(obj *ClusterEvent) error +} + +type clusterEventLifecycleAdapter struct { + lifecycle ClusterEventLifecycle +} + +func (w *clusterEventLifecycleAdapter) Create(obj runtime.Object) error { + return w.lifecycle.Create(obj.(*ClusterEvent)) +} + +func (w *clusterEventLifecycleAdapter) Finalize(obj runtime.Object) error { + return w.lifecycle.Remove(obj.(*ClusterEvent)) +} + +func (w *clusterEventLifecycleAdapter) Updated(obj runtime.Object) error { + return w.lifecycle.Updated(obj.(*ClusterEvent)) +} + +func NewClusterEventLifecycleAdapter(name string, client ClusterEventInterface, l ClusterEventLifecycle) ClusterEventHandlerFunc { + adapter := &clusterEventLifecycleAdapter{lifecycle: l} + syncFn := lifecycle.NewObjectLifecycleAdapter(name, adapter, client.ObjectClient()) + return func(key string, obj *ClusterEvent) error { + if obj == nil { + return syncFn(key, nil) + } + return syncFn(key, obj) + } +} diff --git a/apis/management.cattle.io/v3/zz_generated_deepcopy.go b/apis/management.cattle.io/v3/zz_generated_deepcopy.go index 49bad465..20f3d3a5 100644 --- a/apis/management.cattle.io/v3/zz_generated_deepcopy.go +++ b/apis/management.cattle.io/v3/zz_generated_deepcopy.go @@ -318,6 +318,40 @@ func (in *ClusterEvent) DeepCopyObject() runtime.Object { } } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterEventList) DeepCopyInto(out *ClusterEventList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ClusterEvent, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterEventList. +func (in *ClusterEventList) DeepCopy() *ClusterEventList { + if in == nil { + return nil + } + out := new(ClusterEventList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterEventList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ClusterList) DeepCopyInto(out *ClusterList) { *out = *in diff --git a/apis/management.cattle.io/v3/zz_generated_k8s_client.go b/apis/management.cattle.io/v3/zz_generated_k8s_client.go index bd817f7f..9bece8c8 100644 --- a/apis/management.cattle.io/v3/zz_generated_k8s_client.go +++ b/apis/management.cattle.io/v3/zz_generated_k8s_client.go @@ -23,6 +23,7 @@ type Interface interface { ClusterRoleTemplateBindingsGetter ProjectRoleTemplateBindingsGetter ClustersGetter + ClusterEventsGetter CatalogsGetter TemplatesGetter TemplateVersionsGetter @@ -48,6 +49,7 @@ type Client struct { clusterRoleTemplateBindingControllers map[string]ClusterRoleTemplateBindingController projectRoleTemplateBindingControllers map[string]ProjectRoleTemplateBindingController clusterControllers map[string]ClusterController + clusterEventControllers map[string]ClusterEventController catalogControllers map[string]CatalogController templateControllers map[string]TemplateController templateVersionControllers map[string]TemplateVersionController @@ -82,6 +84,7 @@ func NewForConfig(config rest.Config) (Interface, error) { clusterRoleTemplateBindingControllers: map[string]ClusterRoleTemplateBindingController{}, projectRoleTemplateBindingControllers: map[string]ProjectRoleTemplateBindingController{}, clusterControllers: map[string]ClusterController{}, + clusterEventControllers: map[string]ClusterEventController{}, catalogControllers: map[string]CatalogController{}, templateControllers: map[string]TemplateController{}, templateVersionControllers: map[string]TemplateVersionController{}, @@ -223,6 +226,19 @@ func (c *Client) Clusters(namespace string) ClusterInterface { } } +type ClusterEventsGetter interface { + ClusterEvents(namespace string) ClusterEventInterface +} + +func (c *Client) ClusterEvents(namespace string) ClusterEventInterface { + objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ClusterEventResource, ClusterEventGroupVersionKind, clusterEventFactory{}) + return &clusterEventClient{ + ns: namespace, + client: c, + objectClient: objectClient, + } +} + type CatalogsGetter interface { Catalogs(namespace string) CatalogInterface } diff --git a/client/management/v3/zz_generated_client.go b/client/management/v3/zz_generated_client.go index 9b7d5da3..f005c9af 100644 --- a/client/management/v3/zz_generated_client.go +++ b/client/management/v3/zz_generated_client.go @@ -17,6 +17,7 @@ type Client struct { ClusterRoleTemplateBinding ClusterRoleTemplateBindingOperations ProjectRoleTemplateBinding ProjectRoleTemplateBindingOperations Cluster ClusterOperations + ClusterEvent ClusterEventOperations Catalog CatalogOperations Template TemplateOperations TemplateVersion TemplateVersionOperations @@ -48,6 +49,7 @@ func NewClient(opts *clientbase.ClientOpts) (*Client, error) { client.ClusterRoleTemplateBinding = newClusterRoleTemplateBindingClient(client) client.ProjectRoleTemplateBinding = newProjectRoleTemplateBindingClient(client) client.Cluster = newClusterClient(client) + client.ClusterEvent = newClusterEventClient(client) client.Catalog = newCatalogClient(client) client.Template = newTemplateClient(client) client.TemplateVersion = newTemplateVersionClient(client) diff --git a/client/management/v3/zz_generated_cluster_event.go b/client/management/v3/zz_generated_cluster_event.go new file mode 100644 index 00000000..99b8f610 --- /dev/null +++ b/client/management/v3/zz_generated_cluster_event.go @@ -0,0 +1,111 @@ +package client + +import ( + "github.com/rancher/norman/types" +) + +const ( + ClusterEventType = "clusterEvent" + ClusterEventFieldAnnotations = "annotations" + ClusterEventFieldClusterName = "clusterName" + ClusterEventFieldCount = "count" + ClusterEventFieldCreated = "created" + ClusterEventFieldFinalizers = "finalizers" + ClusterEventFieldFirstTimestamp = "firstTimestamp" + ClusterEventFieldInvolvedObject = "involvedObject" + ClusterEventFieldLabels = "labels" + ClusterEventFieldLastTimestamp = "lastTimestamp" + ClusterEventFieldMessage = "message" + ClusterEventFieldName = "name" + ClusterEventFieldOwnerReferences = "ownerReferences" + ClusterEventFieldReason = "reason" + ClusterEventFieldRemoved = "removed" + ClusterEventFieldResourcePath = "resourcePath" + ClusterEventFieldSource = "source" + ClusterEventFieldType = "type" + ClusterEventFieldUuid = "uuid" +) + +type ClusterEvent struct { + types.Resource + Annotations map[string]string `json:"annotations,omitempty"` + ClusterName string `json:"clusterName,omitempty"` + Count *int64 `json:"count,omitempty"` + Created string `json:"created,omitempty"` + Finalizers []string `json:"finalizers,omitempty"` + FirstTimestamp string `json:"firstTimestamp,omitempty"` + InvolvedObject *ObjectReference `json:"involvedObject,omitempty"` + Labels map[string]string `json:"labels,omitempty"` + LastTimestamp string `json:"lastTimestamp,omitempty"` + Message string `json:"message,omitempty"` + Name string `json:"name,omitempty"` + OwnerReferences []OwnerReference `json:"ownerReferences,omitempty"` + Reason string `json:"reason,omitempty"` + Removed string `json:"removed,omitempty"` + ResourcePath string `json:"resourcePath,omitempty"` + Source *EventSource `json:"source,omitempty"` + Type string `json:"type,omitempty"` + Uuid string `json:"uuid,omitempty"` +} +type ClusterEventCollection struct { + types.Collection + Data []ClusterEvent `json:"data,omitempty"` + client *ClusterEventClient +} + +type ClusterEventClient struct { + apiClient *Client +} + +type ClusterEventOperations interface { + List(opts *types.ListOpts) (*ClusterEventCollection, error) + Create(opts *ClusterEvent) (*ClusterEvent, error) + Update(existing *ClusterEvent, updates interface{}) (*ClusterEvent, error) + ByID(id string) (*ClusterEvent, error) + Delete(container *ClusterEvent) error +} + +func newClusterEventClient(apiClient *Client) *ClusterEventClient { + return &ClusterEventClient{ + apiClient: apiClient, + } +} + +func (c *ClusterEventClient) Create(container *ClusterEvent) (*ClusterEvent, error) { + resp := &ClusterEvent{} + err := c.apiClient.Ops.DoCreate(ClusterEventType, container, resp) + return resp, err +} + +func (c *ClusterEventClient) Update(existing *ClusterEvent, updates interface{}) (*ClusterEvent, error) { + resp := &ClusterEvent{} + err := c.apiClient.Ops.DoUpdate(ClusterEventType, &existing.Resource, updates, resp) + return resp, err +} + +func (c *ClusterEventClient) List(opts *types.ListOpts) (*ClusterEventCollection, error) { + resp := &ClusterEventCollection{} + err := c.apiClient.Ops.DoList(ClusterEventType, opts, resp) + resp.client = c + return resp, err +} + +func (cc *ClusterEventCollection) Next() (*ClusterEventCollection, error) { + if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" { + resp := &ClusterEventCollection{} + err := cc.client.apiClient.Ops.DoNext(cc.Pagination.Next, resp) + resp.client = cc.client + return resp, err + } + return nil, nil +} + +func (c *ClusterEventClient) ByID(id string) (*ClusterEvent, error) { + resp := &ClusterEvent{} + err := c.apiClient.Ops.DoByID(ClusterEventType, id, resp) + return resp, err +} + +func (c *ClusterEventClient) Delete(container *ClusterEvent) error { + return c.apiClient.Ops.DoResourceDelete(ClusterEventType, &container.Resource) +} diff --git a/client/management/v3/zz_generated_event_source.go b/client/management/v3/zz_generated_event_source.go new file mode 100644 index 00000000..60a26638 --- /dev/null +++ b/client/management/v3/zz_generated_event_source.go @@ -0,0 +1,12 @@ +package client + +const ( + EventSourceType = "eventSource" + EventSourceFieldComponent = "component" + EventSourceFieldHost = "host" +) + +type EventSource struct { + Component string `json:"component,omitempty"` + Host string `json:"host,omitempty"` +}