From 7df53e11735b478def31a4bfaef3fb9eabe7df11 Mon Sep 17 00:00:00 2001 From: Darren Shepherd Date: Mon, 26 Nov 2018 08:51:20 -0700 Subject: [PATCH] Update generated code --- .../zz_generated_daemon_set_controller.go | 181 +++++++++++++++++ .../zz_generated_deployment_controller.go | 181 +++++++++++++++++ apis/apps/v1beta2/zz_generated_k8s_client.go | 48 ++++- .../zz_generated_replica_set_controller.go | 181 +++++++++++++++++ .../zz_generated_stateful_set_controller.go | 181 +++++++++++++++++ apis/batch/v1/zz_generated_job_controller.go | 181 +++++++++++++++++ apis/batch/v1/zz_generated_k8s_client.go | 36 +++- .../zz_generated_cron_job_controller.go | 181 +++++++++++++++++ apis/batch/v1beta1/zz_generated_k8s_client.go | 36 +++- ...z_generated_component_status_controller.go | 181 +++++++++++++++++ .../v1/zz_generated_config_map_controller.go | 181 +++++++++++++++++ .../v1/zz_generated_endpoints_controller.go | 181 +++++++++++++++++ apis/core/v1/zz_generated_event_controller.go | 181 +++++++++++++++++ apis/core/v1/zz_generated_k8s_client.go | 84 +++++++- .../v1/zz_generated_namespace_controller.go | 181 +++++++++++++++++ apis/core/v1/zz_generated_node_controller.go | 181 +++++++++++++++++ ...ated_persistent_volume_claim_controller.go | 181 +++++++++++++++++ apis/core/v1/zz_generated_pod_controller.go | 181 +++++++++++++++++ ...rated_replication_controller_controller.go | 181 +++++++++++++++++ .../zz_generated_resource_quota_controller.go | 181 +++++++++++++++++ .../core/v1/zz_generated_secret_controller.go | 181 +++++++++++++++++ ...zz_generated_service_account_controller.go | 181 +++++++++++++++++ .../v1/zz_generated_service_controller.go | 181 +++++++++++++++++ .../zz_generated_ingress_controller.go | 181 +++++++++++++++++ .../v1beta1/zz_generated_k8s_client.go | 40 +++- ...enerated_pod_security_policy_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_auth_config_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_catalog_controller.go | 181 +++++++++++++++++ .../zz_generated_cluster_alert_controller.go | 181 +++++++++++++++++ ...zz_generated_cluster_catalog_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_cluster_controller.go | 181 +++++++++++++++++ ...zz_generated_cluster_logging_controller.go | 181 +++++++++++++++++ ...d_cluster_registration_token_controller.go | 181 +++++++++++++++++ ...luster_role_template_binding_controller.go | 181 +++++++++++++++++ .../zz_generated_compose_config_controller.go | 181 +++++++++++++++++ .../zz_generated_dynamic_schema_controller.go | 181 +++++++++++++++++ ...enerated_global_role_binding_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_global_role_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_group_controller.go | 181 +++++++++++++++++ .../zz_generated_group_member_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_k8s_client.go | 188 +++++++++++++++++- .../v3/zz_generated_ldap_config_controller.go | 181 +++++++++++++++++ .../zz_generated_listen_config_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_node_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_node_driver_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_node_pool_controller.go | 181 +++++++++++++++++ .../zz_generated_node_template_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_notifier_controller.go | 181 +++++++++++++++++ ...pod_security_policy_template_controller.go | 181 +++++++++++++++++ ...icy_template_project_binding_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_preference_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_principal_controller.go | 181 +++++++++++++++++ .../zz_generated_project_alert_controller.go | 181 +++++++++++++++++ ...zz_generated_project_catalog_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_project_controller.go | 181 +++++++++++++++++ ...zz_generated_project_logging_controller.go | 181 +++++++++++++++++ ...rated_project_network_policy_controller.go | 181 +++++++++++++++++ ...roject_role_template_binding_controller.go | 181 +++++++++++++++++ .../zz_generated_role_template_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_setting_controller.go | 181 +++++++++++++++++ ...z_generated_template_content_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_template_controller.go | 181 +++++++++++++++++ ...z_generated_template_version_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_token_controller.go | 181 +++++++++++++++++ .../zz_generated_user_attribute_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_user_controller.go | 181 +++++++++++++++++ .../zz_generated_auth_provider_controller.go | 181 +++++++++++++++++ .../v3public/zz_generated_k8s_client.go | 36 +++- .../v1/zz_generated_k8s_client.go | 36 +++- .../zz_generated_network_policy_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_app_controller.go | 181 +++++++++++++++++ .../zz_generated_app_revision_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_basic_auth_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_certificate_controller.go | 181 +++++++++++++++++ ..._generated_docker_credential_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_k8s_client.go | 112 ++++++++++- ...erated_namespaced_basic_auth_controller.go | 181 +++++++++++++++++ ...rated_namespaced_certificate_controller.go | 181 +++++++++++++++++ ...namespaced_docker_credential_controller.go | 181 +++++++++++++++++ ...spaced_service_account_token_controller.go | 181 +++++++++++++++++ ...enerated_namespaced_ssh_auth_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_pipeline_controller.go | 181 +++++++++++++++++ ...generated_pipeline_execution_controller.go | 181 +++++++++++++++++ ...z_generated_pipeline_setting_controller.go | 181 +++++++++++++++++ ...erated_service_account_token_controller.go | 181 +++++++++++++++++ ...rated_source_code_credential_controller.go | 181 +++++++++++++++++ ..._source_code_provider_config_controller.go | 181 +++++++++++++++++ ...nerated_source_code_provider_controller.go | 181 +++++++++++++++++ ...rated_source_code_repository_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_ssh_auth_controller.go | 181 +++++++++++++++++ .../v3/zz_generated_workload_controller.go | 181 +++++++++++++++++ ...nerated_cluster_role_binding_controller.go | 181 +++++++++++++++++ .../zz_generated_cluster_role_controller.go | 181 +++++++++++++++++ .../v1/zz_generated_k8s_client.go | 48 ++++- .../zz_generated_role_binding_controller.go | 181 +++++++++++++++++ .../v1/zz_generated_role_controller.go | 181 +++++++++++++++++ 96 files changed, 16210 insertions(+), 20 deletions(-) diff --git a/apis/apps/v1beta2/zz_generated_daemon_set_controller.go b/apis/apps/v1beta2/zz_generated_daemon_set_controller.go index 94222ff8..258333ba 100644 --- a/apis/apps/v1beta2/zz_generated_daemon_set_controller.go +++ b/apis/apps/v1beta2/zz_generated_daemon_set_controller.go @@ -38,6 +38,8 @@ type DaemonSetList struct { type DaemonSetHandlerFunc func(key string, obj *v1beta2.DaemonSet) (runtime.Object, error) +type DaemonSetChangeHandlerFunc func(obj *v1beta2.DaemonSet) (runtime.Object, error) + type DaemonSetLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.DaemonSet, err error) Get(namespace, name string) (*v1beta2.DaemonSet, error) @@ -249,3 +251,182 @@ func (s *daemonSetClient) AddClusterScopedLifecycle(ctx context.Context, name, c sync := NewDaemonSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type DaemonSetIndexer func(obj *v1beta2.DaemonSet) ([]string, error) + +type DaemonSetClientCache interface { + Get(namespace, name string) (*v1beta2.DaemonSet, error) + List(namespace string, selector labels.Selector) ([]*v1beta2.DaemonSet, error) + + Index(name string, indexer DaemonSetIndexer) + GetIndexed(name, key string) ([]*v1beta2.DaemonSet, error) +} + +type DaemonSetClient interface { + Create(*v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.DaemonSet, error) + Update(*v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*DaemonSetList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() DaemonSetClientCache + + OnCreate(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() DaemonSetInterface +} + +type daemonSetClientCache struct { + client *daemonSetClient2 +} + +type daemonSetClient2 struct { + iface DaemonSetInterface + controller DaemonSetController +} + +func (n *daemonSetClient2) Interface() DaemonSetInterface { + return n.iface +} + +func (n *daemonSetClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *daemonSetClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *daemonSetClient2) Create(obj *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) { + return n.iface.Create(obj) +} + +func (n *daemonSetClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.DaemonSet, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *daemonSetClient2) Update(obj *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) { + return n.iface.Update(obj) +} + +func (n *daemonSetClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *daemonSetClient2) List(namespace string, opts metav1.ListOptions) (*DaemonSetList, error) { + return n.iface.List(opts) +} + +func (n *daemonSetClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *daemonSetClientCache) Get(namespace, name string) (*v1beta2.DaemonSet, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *daemonSetClientCache) List(namespace string, selector labels.Selector) ([]*v1beta2.DaemonSet, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *daemonSetClient2) Cache() DaemonSetClientCache { + n.loadController() + return &daemonSetClientCache{ + client: n, + } +} + +func (n *daemonSetClient2) OnCreate(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &daemonSetLifecycleDelegate{create: sync}) +} + +func (n *daemonSetClient2) OnChange(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &daemonSetLifecycleDelegate{update: sync}) +} + +func (n *daemonSetClient2) OnRemove(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &daemonSetLifecycleDelegate{remove: sync}) +} + +func (n *daemonSetClientCache) Index(name string, indexer DaemonSetIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta2.DaemonSet); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *daemonSetClientCache) GetIndexed(name, key string) ([]*v1beta2.DaemonSet, error) { + var result []*v1beta2.DaemonSet + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta2.DaemonSet); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *daemonSetClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type daemonSetLifecycleDelegate struct { + create DaemonSetChangeHandlerFunc + update DaemonSetChangeHandlerFunc + remove DaemonSetChangeHandlerFunc +} + +func (n *daemonSetLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *daemonSetLifecycleDelegate) Create(obj *v1beta2.DaemonSet) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *daemonSetLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *daemonSetLifecycleDelegate) Remove(obj *v1beta2.DaemonSet) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *daemonSetLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *daemonSetLifecycleDelegate) Updated(obj *v1beta2.DaemonSet) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/apps/v1beta2/zz_generated_deployment_controller.go b/apis/apps/v1beta2/zz_generated_deployment_controller.go index 4da2fdda..17bf1f9d 100644 --- a/apis/apps/v1beta2/zz_generated_deployment_controller.go +++ b/apis/apps/v1beta2/zz_generated_deployment_controller.go @@ -38,6 +38,8 @@ type DeploymentList struct { type DeploymentHandlerFunc func(key string, obj *v1beta2.Deployment) (runtime.Object, error) +type DeploymentChangeHandlerFunc func(obj *v1beta2.Deployment) (runtime.Object, error) + type DeploymentLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.Deployment, err error) Get(namespace, name string) (*v1beta2.Deployment, error) @@ -249,3 +251,182 @@ func (s *deploymentClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewDeploymentLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type DeploymentIndexer func(obj *v1beta2.Deployment) ([]string, error) + +type DeploymentClientCache interface { + Get(namespace, name string) (*v1beta2.Deployment, error) + List(namespace string, selector labels.Selector) ([]*v1beta2.Deployment, error) + + Index(name string, indexer DeploymentIndexer) + GetIndexed(name, key string) ([]*v1beta2.Deployment, error) +} + +type DeploymentClient interface { + Create(*v1beta2.Deployment) (*v1beta2.Deployment, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.Deployment, error) + Update(*v1beta2.Deployment) (*v1beta2.Deployment, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*DeploymentList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() DeploymentClientCache + + OnCreate(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() DeploymentInterface +} + +type deploymentClientCache struct { + client *deploymentClient2 +} + +type deploymentClient2 struct { + iface DeploymentInterface + controller DeploymentController +} + +func (n *deploymentClient2) Interface() DeploymentInterface { + return n.iface +} + +func (n *deploymentClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *deploymentClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *deploymentClient2) Create(obj *v1beta2.Deployment) (*v1beta2.Deployment, error) { + return n.iface.Create(obj) +} + +func (n *deploymentClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.Deployment, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *deploymentClient2) Update(obj *v1beta2.Deployment) (*v1beta2.Deployment, error) { + return n.iface.Update(obj) +} + +func (n *deploymentClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *deploymentClient2) List(namespace string, opts metav1.ListOptions) (*DeploymentList, error) { + return n.iface.List(opts) +} + +func (n *deploymentClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *deploymentClientCache) Get(namespace, name string) (*v1beta2.Deployment, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *deploymentClientCache) List(namespace string, selector labels.Selector) ([]*v1beta2.Deployment, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *deploymentClient2) Cache() DeploymentClientCache { + n.loadController() + return &deploymentClientCache{ + client: n, + } +} + +func (n *deploymentClient2) OnCreate(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &deploymentLifecycleDelegate{create: sync}) +} + +func (n *deploymentClient2) OnChange(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &deploymentLifecycleDelegate{update: sync}) +} + +func (n *deploymentClient2) OnRemove(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &deploymentLifecycleDelegate{remove: sync}) +} + +func (n *deploymentClientCache) Index(name string, indexer DeploymentIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta2.Deployment); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *deploymentClientCache) GetIndexed(name, key string) ([]*v1beta2.Deployment, error) { + var result []*v1beta2.Deployment + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta2.Deployment); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *deploymentClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type deploymentLifecycleDelegate struct { + create DeploymentChangeHandlerFunc + update DeploymentChangeHandlerFunc + remove DeploymentChangeHandlerFunc +} + +func (n *deploymentLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *deploymentLifecycleDelegate) Create(obj *v1beta2.Deployment) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *deploymentLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *deploymentLifecycleDelegate) Remove(obj *v1beta2.Deployment) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *deploymentLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *deploymentLifecycleDelegate) Updated(obj *v1beta2.Deployment) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/apps/v1beta2/zz_generated_k8s_client.go b/apis/apps/v1beta2/zz_generated_k8s_client.go index bff25c3e..ddd5a134 100644 --- a/apis/apps/v1beta2/zz_generated_k8s_client.go +++ b/apis/apps/v1beta2/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -23,6 +26,13 @@ type Interface interface { ReplicaSetsGetter } +type Clients struct { + Deployment DeploymentClient + DaemonSet DaemonSetClient + StatefulSet StatefulSetClient + ReplicaSet ReplicaSetClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -40,13 +50,47 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + Deployment: &deploymentClient2{ + iface: iface.Deployments(""), + }, + DaemonSet: &daemonSetClient2{ + iface: iface.DaemonSets(""), + }, + StatefulSet: &statefulSetClient2{ + iface: iface.StatefulSets(""), + }, + ReplicaSet: &replicaSetClient2{ + iface: iface.ReplicaSets(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/apps/v1beta2/zz_generated_replica_set_controller.go b/apis/apps/v1beta2/zz_generated_replica_set_controller.go index a12ed8e7..33a651e5 100644 --- a/apis/apps/v1beta2/zz_generated_replica_set_controller.go +++ b/apis/apps/v1beta2/zz_generated_replica_set_controller.go @@ -38,6 +38,8 @@ type ReplicaSetList struct { type ReplicaSetHandlerFunc func(key string, obj *v1beta2.ReplicaSet) (runtime.Object, error) +type ReplicaSetChangeHandlerFunc func(obj *v1beta2.ReplicaSet) (runtime.Object, error) + type ReplicaSetLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.ReplicaSet, err error) Get(namespace, name string) (*v1beta2.ReplicaSet, error) @@ -249,3 +251,182 @@ func (s *replicaSetClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewReplicaSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ReplicaSetIndexer func(obj *v1beta2.ReplicaSet) ([]string, error) + +type ReplicaSetClientCache interface { + Get(namespace, name string) (*v1beta2.ReplicaSet, error) + List(namespace string, selector labels.Selector) ([]*v1beta2.ReplicaSet, error) + + Index(name string, indexer ReplicaSetIndexer) + GetIndexed(name, key string) ([]*v1beta2.ReplicaSet, error) +} + +type ReplicaSetClient interface { + Create(*v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.ReplicaSet, error) + Update(*v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ReplicaSetList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ReplicaSetClientCache + + OnCreate(ctx context.Context, name string, sync ReplicaSetChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ReplicaSetChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ReplicaSetChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ReplicaSetInterface +} + +type replicaSetClientCache struct { + client *replicaSetClient2 +} + +type replicaSetClient2 struct { + iface ReplicaSetInterface + controller ReplicaSetController +} + +func (n *replicaSetClient2) Interface() ReplicaSetInterface { + return n.iface +} + +func (n *replicaSetClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *replicaSetClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *replicaSetClient2) Create(obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) { + return n.iface.Create(obj) +} + +func (n *replicaSetClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.ReplicaSet, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *replicaSetClient2) Update(obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) { + return n.iface.Update(obj) +} + +func (n *replicaSetClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *replicaSetClient2) List(namespace string, opts metav1.ListOptions) (*ReplicaSetList, error) { + return n.iface.List(opts) +} + +func (n *replicaSetClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *replicaSetClientCache) Get(namespace, name string) (*v1beta2.ReplicaSet, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *replicaSetClientCache) List(namespace string, selector labels.Selector) ([]*v1beta2.ReplicaSet, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *replicaSetClient2) Cache() ReplicaSetClientCache { + n.loadController() + return &replicaSetClientCache{ + client: n, + } +} + +func (n *replicaSetClient2) OnCreate(ctx context.Context, name string, sync ReplicaSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &replicaSetLifecycleDelegate{create: sync}) +} + +func (n *replicaSetClient2) OnChange(ctx context.Context, name string, sync ReplicaSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &replicaSetLifecycleDelegate{update: sync}) +} + +func (n *replicaSetClient2) OnRemove(ctx context.Context, name string, sync ReplicaSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &replicaSetLifecycleDelegate{remove: sync}) +} + +func (n *replicaSetClientCache) Index(name string, indexer ReplicaSetIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta2.ReplicaSet); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *replicaSetClientCache) GetIndexed(name, key string) ([]*v1beta2.ReplicaSet, error) { + var result []*v1beta2.ReplicaSet + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta2.ReplicaSet); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *replicaSetClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type replicaSetLifecycleDelegate struct { + create ReplicaSetChangeHandlerFunc + update ReplicaSetChangeHandlerFunc + remove ReplicaSetChangeHandlerFunc +} + +func (n *replicaSetLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *replicaSetLifecycleDelegate) Create(obj *v1beta2.ReplicaSet) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *replicaSetLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *replicaSetLifecycleDelegate) Remove(obj *v1beta2.ReplicaSet) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *replicaSetLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *replicaSetLifecycleDelegate) Updated(obj *v1beta2.ReplicaSet) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/apps/v1beta2/zz_generated_stateful_set_controller.go b/apis/apps/v1beta2/zz_generated_stateful_set_controller.go index 42c84a20..a368bba2 100644 --- a/apis/apps/v1beta2/zz_generated_stateful_set_controller.go +++ b/apis/apps/v1beta2/zz_generated_stateful_set_controller.go @@ -38,6 +38,8 @@ type StatefulSetList struct { type StatefulSetHandlerFunc func(key string, obj *v1beta2.StatefulSet) (runtime.Object, error) +type StatefulSetChangeHandlerFunc func(obj *v1beta2.StatefulSet) (runtime.Object, error) + type StatefulSetLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.StatefulSet, err error) Get(namespace, name string) (*v1beta2.StatefulSet, error) @@ -249,3 +251,182 @@ func (s *statefulSetClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewStatefulSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type StatefulSetIndexer func(obj *v1beta2.StatefulSet) ([]string, error) + +type StatefulSetClientCache interface { + Get(namespace, name string) (*v1beta2.StatefulSet, error) + List(namespace string, selector labels.Selector) ([]*v1beta2.StatefulSet, error) + + Index(name string, indexer StatefulSetIndexer) + GetIndexed(name, key string) ([]*v1beta2.StatefulSet, error) +} + +type StatefulSetClient interface { + Create(*v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.StatefulSet, error) + Update(*v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*StatefulSetList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() StatefulSetClientCache + + OnCreate(ctx context.Context, name string, sync StatefulSetChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync StatefulSetChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync StatefulSetChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() StatefulSetInterface +} + +type statefulSetClientCache struct { + client *statefulSetClient2 +} + +type statefulSetClient2 struct { + iface StatefulSetInterface + controller StatefulSetController +} + +func (n *statefulSetClient2) Interface() StatefulSetInterface { + return n.iface +} + +func (n *statefulSetClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *statefulSetClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *statefulSetClient2) Create(obj *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) { + return n.iface.Create(obj) +} + +func (n *statefulSetClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta2.StatefulSet, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *statefulSetClient2) Update(obj *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) { + return n.iface.Update(obj) +} + +func (n *statefulSetClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *statefulSetClient2) List(namespace string, opts metav1.ListOptions) (*StatefulSetList, error) { + return n.iface.List(opts) +} + +func (n *statefulSetClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *statefulSetClientCache) Get(namespace, name string) (*v1beta2.StatefulSet, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *statefulSetClientCache) List(namespace string, selector labels.Selector) ([]*v1beta2.StatefulSet, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *statefulSetClient2) Cache() StatefulSetClientCache { + n.loadController() + return &statefulSetClientCache{ + client: n, + } +} + +func (n *statefulSetClient2) OnCreate(ctx context.Context, name string, sync StatefulSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &statefulSetLifecycleDelegate{create: sync}) +} + +func (n *statefulSetClient2) OnChange(ctx context.Context, name string, sync StatefulSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &statefulSetLifecycleDelegate{update: sync}) +} + +func (n *statefulSetClient2) OnRemove(ctx context.Context, name string, sync StatefulSetChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &statefulSetLifecycleDelegate{remove: sync}) +} + +func (n *statefulSetClientCache) Index(name string, indexer StatefulSetIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta2.StatefulSet); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *statefulSetClientCache) GetIndexed(name, key string) ([]*v1beta2.StatefulSet, error) { + var result []*v1beta2.StatefulSet + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta2.StatefulSet); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *statefulSetClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type statefulSetLifecycleDelegate struct { + create StatefulSetChangeHandlerFunc + update StatefulSetChangeHandlerFunc + remove StatefulSetChangeHandlerFunc +} + +func (n *statefulSetLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *statefulSetLifecycleDelegate) Create(obj *v1beta2.StatefulSet) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *statefulSetLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *statefulSetLifecycleDelegate) Remove(obj *v1beta2.StatefulSet) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *statefulSetLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *statefulSetLifecycleDelegate) Updated(obj *v1beta2.StatefulSet) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/batch/v1/zz_generated_job_controller.go b/apis/batch/v1/zz_generated_job_controller.go index 32ee8108..312d783b 100644 --- a/apis/batch/v1/zz_generated_job_controller.go +++ b/apis/batch/v1/zz_generated_job_controller.go @@ -38,6 +38,8 @@ type JobList struct { type JobHandlerFunc func(key string, obj *v1.Job) (runtime.Object, error) +type JobChangeHandlerFunc func(obj *v1.Job) (runtime.Object, error) + type JobLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Job, err error) Get(namespace, name string) (*v1.Job, error) @@ -249,3 +251,182 @@ func (s *jobClient) AddClusterScopedLifecycle(ctx context.Context, name, cluster sync := NewJobLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type JobIndexer func(obj *v1.Job) ([]string, error) + +type JobClientCache interface { + Get(namespace, name string) (*v1.Job, error) + List(namespace string, selector labels.Selector) ([]*v1.Job, error) + + Index(name string, indexer JobIndexer) + GetIndexed(name, key string) ([]*v1.Job, error) +} + +type JobClient interface { + Create(*v1.Job) (*v1.Job, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Job, error) + Update(*v1.Job) (*v1.Job, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*JobList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() JobClientCache + + OnCreate(ctx context.Context, name string, sync JobChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync JobChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync JobChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() JobInterface +} + +type jobClientCache struct { + client *jobClient2 +} + +type jobClient2 struct { + iface JobInterface + controller JobController +} + +func (n *jobClient2) Interface() JobInterface { + return n.iface +} + +func (n *jobClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *jobClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *jobClient2) Create(obj *v1.Job) (*v1.Job, error) { + return n.iface.Create(obj) +} + +func (n *jobClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Job, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *jobClient2) Update(obj *v1.Job) (*v1.Job, error) { + return n.iface.Update(obj) +} + +func (n *jobClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *jobClient2) List(namespace string, opts metav1.ListOptions) (*JobList, error) { + return n.iface.List(opts) +} + +func (n *jobClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *jobClientCache) Get(namespace, name string) (*v1.Job, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *jobClientCache) List(namespace string, selector labels.Selector) ([]*v1.Job, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *jobClient2) Cache() JobClientCache { + n.loadController() + return &jobClientCache{ + client: n, + } +} + +func (n *jobClient2) OnCreate(ctx context.Context, name string, sync JobChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &jobLifecycleDelegate{create: sync}) +} + +func (n *jobClient2) OnChange(ctx context.Context, name string, sync JobChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &jobLifecycleDelegate{update: sync}) +} + +func (n *jobClient2) OnRemove(ctx context.Context, name string, sync JobChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &jobLifecycleDelegate{remove: sync}) +} + +func (n *jobClientCache) Index(name string, indexer JobIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Job); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *jobClientCache) GetIndexed(name, key string) ([]*v1.Job, error) { + var result []*v1.Job + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Job); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *jobClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type jobLifecycleDelegate struct { + create JobChangeHandlerFunc + update JobChangeHandlerFunc + remove JobChangeHandlerFunc +} + +func (n *jobLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *jobLifecycleDelegate) Create(obj *v1.Job) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *jobLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *jobLifecycleDelegate) Remove(obj *v1.Job) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *jobLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *jobLifecycleDelegate) Updated(obj *v1.Job) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/batch/v1/zz_generated_k8s_client.go b/apis/batch/v1/zz_generated_k8s_client.go index 46d2eed0..25bd157d 100644 --- a/apis/batch/v1/zz_generated_k8s_client.go +++ b/apis/batch/v1/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -20,6 +23,10 @@ type Interface interface { JobsGetter } +type Clients struct { + Job JobClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -34,13 +41,38 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + Job: &jobClient2{ + iface: iface.Jobs(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/batch/v1beta1/zz_generated_cron_job_controller.go b/apis/batch/v1beta1/zz_generated_cron_job_controller.go index 58d338ab..bcc2683d 100644 --- a/apis/batch/v1beta1/zz_generated_cron_job_controller.go +++ b/apis/batch/v1beta1/zz_generated_cron_job_controller.go @@ -38,6 +38,8 @@ type CronJobList struct { type CronJobHandlerFunc func(key string, obj *v1beta1.CronJob) (runtime.Object, error) +type CronJobChangeHandlerFunc func(obj *v1beta1.CronJob) (runtime.Object, error) + type CronJobLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta1.CronJob, err error) Get(namespace, name string) (*v1beta1.CronJob, error) @@ -249,3 +251,182 @@ func (s *cronJobClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewCronJobLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type CronJobIndexer func(obj *v1beta1.CronJob) ([]string, error) + +type CronJobClientCache interface { + Get(namespace, name string) (*v1beta1.CronJob, error) + List(namespace string, selector labels.Selector) ([]*v1beta1.CronJob, error) + + Index(name string, indexer CronJobIndexer) + GetIndexed(name, key string) ([]*v1beta1.CronJob, error) +} + +type CronJobClient interface { + Create(*v1beta1.CronJob) (*v1beta1.CronJob, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta1.CronJob, error) + Update(*v1beta1.CronJob) (*v1beta1.CronJob, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*CronJobList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() CronJobClientCache + + OnCreate(ctx context.Context, name string, sync CronJobChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync CronJobChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync CronJobChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() CronJobInterface +} + +type cronJobClientCache struct { + client *cronJobClient2 +} + +type cronJobClient2 struct { + iface CronJobInterface + controller CronJobController +} + +func (n *cronJobClient2) Interface() CronJobInterface { + return n.iface +} + +func (n *cronJobClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *cronJobClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *cronJobClient2) Create(obj *v1beta1.CronJob) (*v1beta1.CronJob, error) { + return n.iface.Create(obj) +} + +func (n *cronJobClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta1.CronJob, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *cronJobClient2) Update(obj *v1beta1.CronJob) (*v1beta1.CronJob, error) { + return n.iface.Update(obj) +} + +func (n *cronJobClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *cronJobClient2) List(namespace string, opts metav1.ListOptions) (*CronJobList, error) { + return n.iface.List(opts) +} + +func (n *cronJobClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *cronJobClientCache) Get(namespace, name string) (*v1beta1.CronJob, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *cronJobClientCache) List(namespace string, selector labels.Selector) ([]*v1beta1.CronJob, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *cronJobClient2) Cache() CronJobClientCache { + n.loadController() + return &cronJobClientCache{ + client: n, + } +} + +func (n *cronJobClient2) OnCreate(ctx context.Context, name string, sync CronJobChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &cronJobLifecycleDelegate{create: sync}) +} + +func (n *cronJobClient2) OnChange(ctx context.Context, name string, sync CronJobChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &cronJobLifecycleDelegate{update: sync}) +} + +func (n *cronJobClient2) OnRemove(ctx context.Context, name string, sync CronJobChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &cronJobLifecycleDelegate{remove: sync}) +} + +func (n *cronJobClientCache) Index(name string, indexer CronJobIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta1.CronJob); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *cronJobClientCache) GetIndexed(name, key string) ([]*v1beta1.CronJob, error) { + var result []*v1beta1.CronJob + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta1.CronJob); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *cronJobClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type cronJobLifecycleDelegate struct { + create CronJobChangeHandlerFunc + update CronJobChangeHandlerFunc + remove CronJobChangeHandlerFunc +} + +func (n *cronJobLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *cronJobLifecycleDelegate) Create(obj *v1beta1.CronJob) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *cronJobLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *cronJobLifecycleDelegate) Remove(obj *v1beta1.CronJob) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *cronJobLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *cronJobLifecycleDelegate) Updated(obj *v1beta1.CronJob) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/batch/v1beta1/zz_generated_k8s_client.go b/apis/batch/v1beta1/zz_generated_k8s_client.go index f65bac59..95ea11b2 100644 --- a/apis/batch/v1beta1/zz_generated_k8s_client.go +++ b/apis/batch/v1beta1/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -20,6 +23,10 @@ type Interface interface { CronJobsGetter } +type Clients struct { + CronJob CronJobClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -34,13 +41,38 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + CronJob: &cronJobClient2{ + iface: iface.CronJobs(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/core/v1/zz_generated_component_status_controller.go b/apis/core/v1/zz_generated_component_status_controller.go index 0e4c6073..c97c9b17 100644 --- a/apis/core/v1/zz_generated_component_status_controller.go +++ b/apis/core/v1/zz_generated_component_status_controller.go @@ -37,6 +37,8 @@ type ComponentStatusList struct { type ComponentStatusHandlerFunc func(key string, obj *v1.ComponentStatus) (runtime.Object, error) +type ComponentStatusChangeHandlerFunc func(obj *v1.ComponentStatus) (runtime.Object, error) + type ComponentStatusLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ComponentStatus, err error) Get(namespace, name string) (*v1.ComponentStatus, error) @@ -248,3 +250,182 @@ func (s *componentStatusClient) AddClusterScopedLifecycle(ctx context.Context, n sync := NewComponentStatusLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ComponentStatusIndexer func(obj *v1.ComponentStatus) ([]string, error) + +type ComponentStatusClientCache interface { + Get(namespace, name string) (*v1.ComponentStatus, error) + List(namespace string, selector labels.Selector) ([]*v1.ComponentStatus, error) + + Index(name string, indexer ComponentStatusIndexer) + GetIndexed(name, key string) ([]*v1.ComponentStatus, error) +} + +type ComponentStatusClient interface { + Create(*v1.ComponentStatus) (*v1.ComponentStatus, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ComponentStatus, error) + Update(*v1.ComponentStatus) (*v1.ComponentStatus, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ComponentStatusList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ComponentStatusClientCache + + OnCreate(ctx context.Context, name string, sync ComponentStatusChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ComponentStatusChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ComponentStatusChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ComponentStatusInterface +} + +type componentStatusClientCache struct { + client *componentStatusClient2 +} + +type componentStatusClient2 struct { + iface ComponentStatusInterface + controller ComponentStatusController +} + +func (n *componentStatusClient2) Interface() ComponentStatusInterface { + return n.iface +} + +func (n *componentStatusClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *componentStatusClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *componentStatusClient2) Create(obj *v1.ComponentStatus) (*v1.ComponentStatus, error) { + return n.iface.Create(obj) +} + +func (n *componentStatusClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ComponentStatus, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *componentStatusClient2) Update(obj *v1.ComponentStatus) (*v1.ComponentStatus, error) { + return n.iface.Update(obj) +} + +func (n *componentStatusClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *componentStatusClient2) List(namespace string, opts metav1.ListOptions) (*ComponentStatusList, error) { + return n.iface.List(opts) +} + +func (n *componentStatusClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *componentStatusClientCache) Get(namespace, name string) (*v1.ComponentStatus, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *componentStatusClientCache) List(namespace string, selector labels.Selector) ([]*v1.ComponentStatus, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *componentStatusClient2) Cache() ComponentStatusClientCache { + n.loadController() + return &componentStatusClientCache{ + client: n, + } +} + +func (n *componentStatusClient2) OnCreate(ctx context.Context, name string, sync ComponentStatusChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &componentStatusLifecycleDelegate{create: sync}) +} + +func (n *componentStatusClient2) OnChange(ctx context.Context, name string, sync ComponentStatusChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &componentStatusLifecycleDelegate{update: sync}) +} + +func (n *componentStatusClient2) OnRemove(ctx context.Context, name string, sync ComponentStatusChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &componentStatusLifecycleDelegate{remove: sync}) +} + +func (n *componentStatusClientCache) Index(name string, indexer ComponentStatusIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ComponentStatus); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *componentStatusClientCache) GetIndexed(name, key string) ([]*v1.ComponentStatus, error) { + var result []*v1.ComponentStatus + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ComponentStatus); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *componentStatusClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type componentStatusLifecycleDelegate struct { + create ComponentStatusChangeHandlerFunc + update ComponentStatusChangeHandlerFunc + remove ComponentStatusChangeHandlerFunc +} + +func (n *componentStatusLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *componentStatusLifecycleDelegate) Create(obj *v1.ComponentStatus) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *componentStatusLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *componentStatusLifecycleDelegate) Remove(obj *v1.ComponentStatus) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *componentStatusLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *componentStatusLifecycleDelegate) Updated(obj *v1.ComponentStatus) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_config_map_controller.go b/apis/core/v1/zz_generated_config_map_controller.go index 8fc58e97..94157ac3 100644 --- a/apis/core/v1/zz_generated_config_map_controller.go +++ b/apis/core/v1/zz_generated_config_map_controller.go @@ -38,6 +38,8 @@ type ConfigMapList struct { type ConfigMapHandlerFunc func(key string, obj *v1.ConfigMap) (runtime.Object, error) +type ConfigMapChangeHandlerFunc func(obj *v1.ConfigMap) (runtime.Object, error) + type ConfigMapLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ConfigMap, err error) Get(namespace, name string) (*v1.ConfigMap, error) @@ -249,3 +251,182 @@ func (s *configMapClient) AddClusterScopedLifecycle(ctx context.Context, name, c sync := NewConfigMapLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ConfigMapIndexer func(obj *v1.ConfigMap) ([]string, error) + +type ConfigMapClientCache interface { + Get(namespace, name string) (*v1.ConfigMap, error) + List(namespace string, selector labels.Selector) ([]*v1.ConfigMap, error) + + Index(name string, indexer ConfigMapIndexer) + GetIndexed(name, key string) ([]*v1.ConfigMap, error) +} + +type ConfigMapClient interface { + Create(*v1.ConfigMap) (*v1.ConfigMap, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ConfigMap, error) + Update(*v1.ConfigMap) (*v1.ConfigMap, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ConfigMapList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ConfigMapClientCache + + OnCreate(ctx context.Context, name string, sync ConfigMapChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ConfigMapChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ConfigMapChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ConfigMapInterface +} + +type configMapClientCache struct { + client *configMapClient2 +} + +type configMapClient2 struct { + iface ConfigMapInterface + controller ConfigMapController +} + +func (n *configMapClient2) Interface() ConfigMapInterface { + return n.iface +} + +func (n *configMapClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *configMapClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *configMapClient2) Create(obj *v1.ConfigMap) (*v1.ConfigMap, error) { + return n.iface.Create(obj) +} + +func (n *configMapClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ConfigMap, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *configMapClient2) Update(obj *v1.ConfigMap) (*v1.ConfigMap, error) { + return n.iface.Update(obj) +} + +func (n *configMapClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *configMapClient2) List(namespace string, opts metav1.ListOptions) (*ConfigMapList, error) { + return n.iface.List(opts) +} + +func (n *configMapClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *configMapClientCache) Get(namespace, name string) (*v1.ConfigMap, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *configMapClientCache) List(namespace string, selector labels.Selector) ([]*v1.ConfigMap, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *configMapClient2) Cache() ConfigMapClientCache { + n.loadController() + return &configMapClientCache{ + client: n, + } +} + +func (n *configMapClient2) OnCreate(ctx context.Context, name string, sync ConfigMapChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &configMapLifecycleDelegate{create: sync}) +} + +func (n *configMapClient2) OnChange(ctx context.Context, name string, sync ConfigMapChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &configMapLifecycleDelegate{update: sync}) +} + +func (n *configMapClient2) OnRemove(ctx context.Context, name string, sync ConfigMapChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &configMapLifecycleDelegate{remove: sync}) +} + +func (n *configMapClientCache) Index(name string, indexer ConfigMapIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ConfigMap); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *configMapClientCache) GetIndexed(name, key string) ([]*v1.ConfigMap, error) { + var result []*v1.ConfigMap + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ConfigMap); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *configMapClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type configMapLifecycleDelegate struct { + create ConfigMapChangeHandlerFunc + update ConfigMapChangeHandlerFunc + remove ConfigMapChangeHandlerFunc +} + +func (n *configMapLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *configMapLifecycleDelegate) Create(obj *v1.ConfigMap) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *configMapLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *configMapLifecycleDelegate) Remove(obj *v1.ConfigMap) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *configMapLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *configMapLifecycleDelegate) Updated(obj *v1.ConfigMap) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_endpoints_controller.go b/apis/core/v1/zz_generated_endpoints_controller.go index ebbb81f1..0bbe347e 100644 --- a/apis/core/v1/zz_generated_endpoints_controller.go +++ b/apis/core/v1/zz_generated_endpoints_controller.go @@ -38,6 +38,8 @@ type EndpointsList struct { type EndpointsHandlerFunc func(key string, obj *v1.Endpoints) (runtime.Object, error) +type EndpointsChangeHandlerFunc func(obj *v1.Endpoints) (runtime.Object, error) + type EndpointsLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Endpoints, err error) Get(namespace, name string) (*v1.Endpoints, error) @@ -249,3 +251,182 @@ func (s *endpointsClient) AddClusterScopedLifecycle(ctx context.Context, name, c sync := NewEndpointsLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type EndpointsIndexer func(obj *v1.Endpoints) ([]string, error) + +type EndpointsClientCache interface { + Get(namespace, name string) (*v1.Endpoints, error) + List(namespace string, selector labels.Selector) ([]*v1.Endpoints, error) + + Index(name string, indexer EndpointsIndexer) + GetIndexed(name, key string) ([]*v1.Endpoints, error) +} + +type EndpointsClient interface { + Create(*v1.Endpoints) (*v1.Endpoints, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Endpoints, error) + Update(*v1.Endpoints) (*v1.Endpoints, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*EndpointsList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() EndpointsClientCache + + OnCreate(ctx context.Context, name string, sync EndpointsChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync EndpointsChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync EndpointsChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() EndpointsInterface +} + +type endpointsClientCache struct { + client *endpointsClient2 +} + +type endpointsClient2 struct { + iface EndpointsInterface + controller EndpointsController +} + +func (n *endpointsClient2) Interface() EndpointsInterface { + return n.iface +} + +func (n *endpointsClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *endpointsClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *endpointsClient2) Create(obj *v1.Endpoints) (*v1.Endpoints, error) { + return n.iface.Create(obj) +} + +func (n *endpointsClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Endpoints, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *endpointsClient2) Update(obj *v1.Endpoints) (*v1.Endpoints, error) { + return n.iface.Update(obj) +} + +func (n *endpointsClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *endpointsClient2) List(namespace string, opts metav1.ListOptions) (*EndpointsList, error) { + return n.iface.List(opts) +} + +func (n *endpointsClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *endpointsClientCache) Get(namespace, name string) (*v1.Endpoints, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *endpointsClientCache) List(namespace string, selector labels.Selector) ([]*v1.Endpoints, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *endpointsClient2) Cache() EndpointsClientCache { + n.loadController() + return &endpointsClientCache{ + client: n, + } +} + +func (n *endpointsClient2) OnCreate(ctx context.Context, name string, sync EndpointsChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &endpointsLifecycleDelegate{create: sync}) +} + +func (n *endpointsClient2) OnChange(ctx context.Context, name string, sync EndpointsChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &endpointsLifecycleDelegate{update: sync}) +} + +func (n *endpointsClient2) OnRemove(ctx context.Context, name string, sync EndpointsChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &endpointsLifecycleDelegate{remove: sync}) +} + +func (n *endpointsClientCache) Index(name string, indexer EndpointsIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Endpoints); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *endpointsClientCache) GetIndexed(name, key string) ([]*v1.Endpoints, error) { + var result []*v1.Endpoints + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Endpoints); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *endpointsClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type endpointsLifecycleDelegate struct { + create EndpointsChangeHandlerFunc + update EndpointsChangeHandlerFunc + remove EndpointsChangeHandlerFunc +} + +func (n *endpointsLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *endpointsLifecycleDelegate) Create(obj *v1.Endpoints) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *endpointsLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *endpointsLifecycleDelegate) Remove(obj *v1.Endpoints) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *endpointsLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *endpointsLifecycleDelegate) Updated(obj *v1.Endpoints) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_event_controller.go b/apis/core/v1/zz_generated_event_controller.go index 218ff4a9..eb59c749 100644 --- a/apis/core/v1/zz_generated_event_controller.go +++ b/apis/core/v1/zz_generated_event_controller.go @@ -37,6 +37,8 @@ type EventList struct { type EventHandlerFunc func(key string, obj *v1.Event) (runtime.Object, error) +type EventChangeHandlerFunc func(obj *v1.Event) (runtime.Object, error) + type EventLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Event, err error) Get(namespace, name string) (*v1.Event, error) @@ -248,3 +250,182 @@ func (s *eventClient) AddClusterScopedLifecycle(ctx context.Context, name, clust sync := NewEventLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type EventIndexer func(obj *v1.Event) ([]string, error) + +type EventClientCache interface { + Get(namespace, name string) (*v1.Event, error) + List(namespace string, selector labels.Selector) ([]*v1.Event, error) + + Index(name string, indexer EventIndexer) + GetIndexed(name, key string) ([]*v1.Event, error) +} + +type EventClient interface { + Create(*v1.Event) (*v1.Event, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Event, error) + Update(*v1.Event) (*v1.Event, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*EventList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() EventClientCache + + OnCreate(ctx context.Context, name string, sync EventChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync EventChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync EventChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() EventInterface +} + +type eventClientCache struct { + client *eventClient2 +} + +type eventClient2 struct { + iface EventInterface + controller EventController +} + +func (n *eventClient2) Interface() EventInterface { + return n.iface +} + +func (n *eventClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *eventClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *eventClient2) Create(obj *v1.Event) (*v1.Event, error) { + return n.iface.Create(obj) +} + +func (n *eventClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Event, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *eventClient2) Update(obj *v1.Event) (*v1.Event, error) { + return n.iface.Update(obj) +} + +func (n *eventClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *eventClient2) List(namespace string, opts metav1.ListOptions) (*EventList, error) { + return n.iface.List(opts) +} + +func (n *eventClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *eventClientCache) Get(namespace, name string) (*v1.Event, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *eventClientCache) List(namespace string, selector labels.Selector) ([]*v1.Event, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *eventClient2) Cache() EventClientCache { + n.loadController() + return &eventClientCache{ + client: n, + } +} + +func (n *eventClient2) OnCreate(ctx context.Context, name string, sync EventChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &eventLifecycleDelegate{create: sync}) +} + +func (n *eventClient2) OnChange(ctx context.Context, name string, sync EventChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &eventLifecycleDelegate{update: sync}) +} + +func (n *eventClient2) OnRemove(ctx context.Context, name string, sync EventChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &eventLifecycleDelegate{remove: sync}) +} + +func (n *eventClientCache) Index(name string, indexer EventIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Event); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *eventClientCache) GetIndexed(name, key string) ([]*v1.Event, error) { + var result []*v1.Event + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Event); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *eventClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type eventLifecycleDelegate struct { + create EventChangeHandlerFunc + update EventChangeHandlerFunc + remove EventChangeHandlerFunc +} + +func (n *eventLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *eventLifecycleDelegate) Create(obj *v1.Event) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *eventLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *eventLifecycleDelegate) Remove(obj *v1.Event) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *eventLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *eventLifecycleDelegate) Updated(obj *v1.Event) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_k8s_client.go b/apis/core/v1/zz_generated_k8s_client.go index 6c8aa26a..66e4fa43 100644 --- a/apis/core/v1/zz_generated_k8s_client.go +++ b/apis/core/v1/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -32,6 +35,22 @@ type Interface interface { ResourceQuotasGetter } +type Clients struct { + Node NodeClient + ComponentStatus ComponentStatusClient + Namespace NamespaceClient + Event EventClient + Endpoints EndpointsClient + PersistentVolumeClaim PersistentVolumeClaimClient + Pod PodClient + Service ServiceClient + Secret SecretClient + ConfigMap ConfigMapClient + ServiceAccount ServiceAccountClient + ReplicationController ReplicationControllerClient + ResourceQuota ResourceQuotaClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -58,13 +77,74 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + Node: &nodeClient2{ + iface: iface.Nodes(""), + }, + ComponentStatus: &componentStatusClient2{ + iface: iface.ComponentStatuses(""), + }, + Namespace: &namespaceClient2{ + iface: iface.Namespaces(""), + }, + Event: &eventClient2{ + iface: iface.Events(""), + }, + Endpoints: &endpointsClient2{ + iface: iface.Endpoints(""), + }, + PersistentVolumeClaim: &persistentVolumeClaimClient2{ + iface: iface.PersistentVolumeClaims(""), + }, + Pod: &podClient2{ + iface: iface.Pods(""), + }, + Service: &serviceClient2{ + iface: iface.Services(""), + }, + Secret: &secretClient2{ + iface: iface.Secrets(""), + }, + ConfigMap: &configMapClient2{ + iface: iface.ConfigMaps(""), + }, + ServiceAccount: &serviceAccountClient2{ + iface: iface.ServiceAccounts(""), + }, + ReplicationController: &replicationControllerClient2{ + iface: iface.ReplicationControllers(""), + }, + ResourceQuota: &resourceQuotaClient2{ + iface: iface.ResourceQuotas(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/core/v1/zz_generated_namespace_controller.go b/apis/core/v1/zz_generated_namespace_controller.go index 4aaf4eda..7ca011c9 100644 --- a/apis/core/v1/zz_generated_namespace_controller.go +++ b/apis/core/v1/zz_generated_namespace_controller.go @@ -37,6 +37,8 @@ type NamespaceList struct { type NamespaceHandlerFunc func(key string, obj *v1.Namespace) (runtime.Object, error) +type NamespaceChangeHandlerFunc func(obj *v1.Namespace) (runtime.Object, error) + type NamespaceLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Namespace, err error) Get(namespace, name string) (*v1.Namespace, error) @@ -248,3 +250,182 @@ func (s *namespaceClient) AddClusterScopedLifecycle(ctx context.Context, name, c sync := NewNamespaceLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NamespaceIndexer func(obj *v1.Namespace) ([]string, error) + +type NamespaceClientCache interface { + Get(namespace, name string) (*v1.Namespace, error) + List(namespace string, selector labels.Selector) ([]*v1.Namespace, error) + + Index(name string, indexer NamespaceIndexer) + GetIndexed(name, key string) ([]*v1.Namespace, error) +} + +type NamespaceClient interface { + Create(*v1.Namespace) (*v1.Namespace, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Namespace, error) + Update(*v1.Namespace) (*v1.Namespace, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NamespaceList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NamespaceClientCache + + OnCreate(ctx context.Context, name string, sync NamespaceChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NamespaceChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NamespaceChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NamespaceInterface +} + +type namespaceClientCache struct { + client *namespaceClient2 +} + +type namespaceClient2 struct { + iface NamespaceInterface + controller NamespaceController +} + +func (n *namespaceClient2) Interface() NamespaceInterface { + return n.iface +} + +func (n *namespaceClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *namespaceClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *namespaceClient2) Create(obj *v1.Namespace) (*v1.Namespace, error) { + return n.iface.Create(obj) +} + +func (n *namespaceClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Namespace, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *namespaceClient2) Update(obj *v1.Namespace) (*v1.Namespace, error) { + return n.iface.Update(obj) +} + +func (n *namespaceClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *namespaceClient2) List(namespace string, opts metav1.ListOptions) (*NamespaceList, error) { + return n.iface.List(opts) +} + +func (n *namespaceClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *namespaceClientCache) Get(namespace, name string) (*v1.Namespace, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *namespaceClientCache) List(namespace string, selector labels.Selector) ([]*v1.Namespace, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *namespaceClient2) Cache() NamespaceClientCache { + n.loadController() + return &namespaceClientCache{ + client: n, + } +} + +func (n *namespaceClient2) OnCreate(ctx context.Context, name string, sync NamespaceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespaceLifecycleDelegate{create: sync}) +} + +func (n *namespaceClient2) OnChange(ctx context.Context, name string, sync NamespaceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespaceLifecycleDelegate{update: sync}) +} + +func (n *namespaceClient2) OnRemove(ctx context.Context, name string, sync NamespaceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespaceLifecycleDelegate{remove: sync}) +} + +func (n *namespaceClientCache) Index(name string, indexer NamespaceIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Namespace); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *namespaceClientCache) GetIndexed(name, key string) ([]*v1.Namespace, error) { + var result []*v1.Namespace + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Namespace); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *namespaceClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type namespaceLifecycleDelegate struct { + create NamespaceChangeHandlerFunc + update NamespaceChangeHandlerFunc + remove NamespaceChangeHandlerFunc +} + +func (n *namespaceLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *namespaceLifecycleDelegate) Create(obj *v1.Namespace) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *namespaceLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *namespaceLifecycleDelegate) Remove(obj *v1.Namespace) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *namespaceLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *namespaceLifecycleDelegate) Updated(obj *v1.Namespace) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_node_controller.go b/apis/core/v1/zz_generated_node_controller.go index ae889471..38935621 100644 --- a/apis/core/v1/zz_generated_node_controller.go +++ b/apis/core/v1/zz_generated_node_controller.go @@ -37,6 +37,8 @@ type NodeList struct { type NodeHandlerFunc func(key string, obj *v1.Node) (runtime.Object, error) +type NodeChangeHandlerFunc func(obj *v1.Node) (runtime.Object, error) + type NodeLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Node, err error) Get(namespace, name string) (*v1.Node, error) @@ -248,3 +250,182 @@ func (s *nodeClient) AddClusterScopedLifecycle(ctx context.Context, name, cluste sync := NewNodeLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NodeIndexer func(obj *v1.Node) ([]string, error) + +type NodeClientCache interface { + Get(namespace, name string) (*v1.Node, error) + List(namespace string, selector labels.Selector) ([]*v1.Node, error) + + Index(name string, indexer NodeIndexer) + GetIndexed(name, key string) ([]*v1.Node, error) +} + +type NodeClient interface { + Create(*v1.Node) (*v1.Node, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Node, error) + Update(*v1.Node) (*v1.Node, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NodeList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NodeClientCache + + OnCreate(ctx context.Context, name string, sync NodeChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NodeChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NodeChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NodeInterface +} + +type nodeClientCache struct { + client *nodeClient2 +} + +type nodeClient2 struct { + iface NodeInterface + controller NodeController +} + +func (n *nodeClient2) Interface() NodeInterface { + return n.iface +} + +func (n *nodeClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *nodeClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *nodeClient2) Create(obj *v1.Node) (*v1.Node, error) { + return n.iface.Create(obj) +} + +func (n *nodeClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Node, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *nodeClient2) Update(obj *v1.Node) (*v1.Node, error) { + return n.iface.Update(obj) +} + +func (n *nodeClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *nodeClient2) List(namespace string, opts metav1.ListOptions) (*NodeList, error) { + return n.iface.List(opts) +} + +func (n *nodeClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *nodeClientCache) Get(namespace, name string) (*v1.Node, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *nodeClientCache) List(namespace string, selector labels.Selector) ([]*v1.Node, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *nodeClient2) Cache() NodeClientCache { + n.loadController() + return &nodeClientCache{ + client: n, + } +} + +func (n *nodeClient2) OnCreate(ctx context.Context, name string, sync NodeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeLifecycleDelegate{create: sync}) +} + +func (n *nodeClient2) OnChange(ctx context.Context, name string, sync NodeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeLifecycleDelegate{update: sync}) +} + +func (n *nodeClient2) OnRemove(ctx context.Context, name string, sync NodeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeLifecycleDelegate{remove: sync}) +} + +func (n *nodeClientCache) Index(name string, indexer NodeIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Node); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *nodeClientCache) GetIndexed(name, key string) ([]*v1.Node, error) { + var result []*v1.Node + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Node); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *nodeClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type nodeLifecycleDelegate struct { + create NodeChangeHandlerFunc + update NodeChangeHandlerFunc + remove NodeChangeHandlerFunc +} + +func (n *nodeLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *nodeLifecycleDelegate) Create(obj *v1.Node) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *nodeLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *nodeLifecycleDelegate) Remove(obj *v1.Node) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *nodeLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *nodeLifecycleDelegate) Updated(obj *v1.Node) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_persistent_volume_claim_controller.go b/apis/core/v1/zz_generated_persistent_volume_claim_controller.go index fafcb764..6e2d1568 100644 --- a/apis/core/v1/zz_generated_persistent_volume_claim_controller.go +++ b/apis/core/v1/zz_generated_persistent_volume_claim_controller.go @@ -38,6 +38,8 @@ type PersistentVolumeClaimList struct { type PersistentVolumeClaimHandlerFunc func(key string, obj *v1.PersistentVolumeClaim) (runtime.Object, error) +type PersistentVolumeClaimChangeHandlerFunc func(obj *v1.PersistentVolumeClaim) (runtime.Object, error) + type PersistentVolumeClaimLister interface { List(namespace string, selector labels.Selector) (ret []*v1.PersistentVolumeClaim, err error) Get(namespace, name string) (*v1.PersistentVolumeClaim, error) @@ -249,3 +251,182 @@ func (s *persistentVolumeClaimClient) AddClusterScopedLifecycle(ctx context.Cont sync := NewPersistentVolumeClaimLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PersistentVolumeClaimIndexer func(obj *v1.PersistentVolumeClaim) ([]string, error) + +type PersistentVolumeClaimClientCache interface { + Get(namespace, name string) (*v1.PersistentVolumeClaim, error) + List(namespace string, selector labels.Selector) ([]*v1.PersistentVolumeClaim, error) + + Index(name string, indexer PersistentVolumeClaimIndexer) + GetIndexed(name, key string) ([]*v1.PersistentVolumeClaim, error) +} + +type PersistentVolumeClaimClient interface { + Create(*v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.PersistentVolumeClaim, error) + Update(*v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PersistentVolumeClaimList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PersistentVolumeClaimClientCache + + OnCreate(ctx context.Context, name string, sync PersistentVolumeClaimChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PersistentVolumeClaimChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PersistentVolumeClaimChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PersistentVolumeClaimInterface +} + +type persistentVolumeClaimClientCache struct { + client *persistentVolumeClaimClient2 +} + +type persistentVolumeClaimClient2 struct { + iface PersistentVolumeClaimInterface + controller PersistentVolumeClaimController +} + +func (n *persistentVolumeClaimClient2) Interface() PersistentVolumeClaimInterface { + return n.iface +} + +func (n *persistentVolumeClaimClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *persistentVolumeClaimClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *persistentVolumeClaimClient2) Create(obj *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) { + return n.iface.Create(obj) +} + +func (n *persistentVolumeClaimClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.PersistentVolumeClaim, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *persistentVolumeClaimClient2) Update(obj *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) { + return n.iface.Update(obj) +} + +func (n *persistentVolumeClaimClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *persistentVolumeClaimClient2) List(namespace string, opts metav1.ListOptions) (*PersistentVolumeClaimList, error) { + return n.iface.List(opts) +} + +func (n *persistentVolumeClaimClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *persistentVolumeClaimClientCache) Get(namespace, name string) (*v1.PersistentVolumeClaim, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *persistentVolumeClaimClientCache) List(namespace string, selector labels.Selector) ([]*v1.PersistentVolumeClaim, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *persistentVolumeClaimClient2) Cache() PersistentVolumeClaimClientCache { + n.loadController() + return &persistentVolumeClaimClientCache{ + client: n, + } +} + +func (n *persistentVolumeClaimClient2) OnCreate(ctx context.Context, name string, sync PersistentVolumeClaimChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &persistentVolumeClaimLifecycleDelegate{create: sync}) +} + +func (n *persistentVolumeClaimClient2) OnChange(ctx context.Context, name string, sync PersistentVolumeClaimChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &persistentVolumeClaimLifecycleDelegate{update: sync}) +} + +func (n *persistentVolumeClaimClient2) OnRemove(ctx context.Context, name string, sync PersistentVolumeClaimChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &persistentVolumeClaimLifecycleDelegate{remove: sync}) +} + +func (n *persistentVolumeClaimClientCache) Index(name string, indexer PersistentVolumeClaimIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.PersistentVolumeClaim); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *persistentVolumeClaimClientCache) GetIndexed(name, key string) ([]*v1.PersistentVolumeClaim, error) { + var result []*v1.PersistentVolumeClaim + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.PersistentVolumeClaim); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *persistentVolumeClaimClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type persistentVolumeClaimLifecycleDelegate struct { + create PersistentVolumeClaimChangeHandlerFunc + update PersistentVolumeClaimChangeHandlerFunc + remove PersistentVolumeClaimChangeHandlerFunc +} + +func (n *persistentVolumeClaimLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *persistentVolumeClaimLifecycleDelegate) Create(obj *v1.PersistentVolumeClaim) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *persistentVolumeClaimLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *persistentVolumeClaimLifecycleDelegate) Remove(obj *v1.PersistentVolumeClaim) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *persistentVolumeClaimLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *persistentVolumeClaimLifecycleDelegate) Updated(obj *v1.PersistentVolumeClaim) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_pod_controller.go b/apis/core/v1/zz_generated_pod_controller.go index cc168028..b3cedf6f 100644 --- a/apis/core/v1/zz_generated_pod_controller.go +++ b/apis/core/v1/zz_generated_pod_controller.go @@ -38,6 +38,8 @@ type PodList struct { type PodHandlerFunc func(key string, obj *v1.Pod) (runtime.Object, error) +type PodChangeHandlerFunc func(obj *v1.Pod) (runtime.Object, error) + type PodLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Pod, err error) Get(namespace, name string) (*v1.Pod, error) @@ -249,3 +251,182 @@ func (s *podClient) AddClusterScopedLifecycle(ctx context.Context, name, cluster sync := NewPodLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PodIndexer func(obj *v1.Pod) ([]string, error) + +type PodClientCache interface { + Get(namespace, name string) (*v1.Pod, error) + List(namespace string, selector labels.Selector) ([]*v1.Pod, error) + + Index(name string, indexer PodIndexer) + GetIndexed(name, key string) ([]*v1.Pod, error) +} + +type PodClient interface { + Create(*v1.Pod) (*v1.Pod, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Pod, error) + Update(*v1.Pod) (*v1.Pod, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PodList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PodClientCache + + OnCreate(ctx context.Context, name string, sync PodChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PodChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PodChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PodInterface +} + +type podClientCache struct { + client *podClient2 +} + +type podClient2 struct { + iface PodInterface + controller PodController +} + +func (n *podClient2) Interface() PodInterface { + return n.iface +} + +func (n *podClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *podClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *podClient2) Create(obj *v1.Pod) (*v1.Pod, error) { + return n.iface.Create(obj) +} + +func (n *podClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Pod, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *podClient2) Update(obj *v1.Pod) (*v1.Pod, error) { + return n.iface.Update(obj) +} + +func (n *podClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *podClient2) List(namespace string, opts metav1.ListOptions) (*PodList, error) { + return n.iface.List(opts) +} + +func (n *podClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *podClientCache) Get(namespace, name string) (*v1.Pod, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *podClientCache) List(namespace string, selector labels.Selector) ([]*v1.Pod, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *podClient2) Cache() PodClientCache { + n.loadController() + return &podClientCache{ + client: n, + } +} + +func (n *podClient2) OnCreate(ctx context.Context, name string, sync PodChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podLifecycleDelegate{create: sync}) +} + +func (n *podClient2) OnChange(ctx context.Context, name string, sync PodChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podLifecycleDelegate{update: sync}) +} + +func (n *podClient2) OnRemove(ctx context.Context, name string, sync PodChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podLifecycleDelegate{remove: sync}) +} + +func (n *podClientCache) Index(name string, indexer PodIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Pod); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *podClientCache) GetIndexed(name, key string) ([]*v1.Pod, error) { + var result []*v1.Pod + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Pod); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *podClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type podLifecycleDelegate struct { + create PodChangeHandlerFunc + update PodChangeHandlerFunc + remove PodChangeHandlerFunc +} + +func (n *podLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *podLifecycleDelegate) Create(obj *v1.Pod) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *podLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *podLifecycleDelegate) Remove(obj *v1.Pod) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *podLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *podLifecycleDelegate) Updated(obj *v1.Pod) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_replication_controller_controller.go b/apis/core/v1/zz_generated_replication_controller_controller.go index 1d93a420..71c0f1ca 100644 --- a/apis/core/v1/zz_generated_replication_controller_controller.go +++ b/apis/core/v1/zz_generated_replication_controller_controller.go @@ -38,6 +38,8 @@ type ReplicationControllerList struct { type ReplicationControllerHandlerFunc func(key string, obj *v1.ReplicationController) (runtime.Object, error) +type ReplicationControllerChangeHandlerFunc func(obj *v1.ReplicationController) (runtime.Object, error) + type ReplicationControllerLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ReplicationController, err error) Get(namespace, name string) (*v1.ReplicationController, error) @@ -249,3 +251,182 @@ func (s *replicationControllerClient) AddClusterScopedLifecycle(ctx context.Cont sync := NewReplicationControllerLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ReplicationControllerIndexer func(obj *v1.ReplicationController) ([]string, error) + +type ReplicationControllerClientCache interface { + Get(namespace, name string) (*v1.ReplicationController, error) + List(namespace string, selector labels.Selector) ([]*v1.ReplicationController, error) + + Index(name string, indexer ReplicationControllerIndexer) + GetIndexed(name, key string) ([]*v1.ReplicationController, error) +} + +type ReplicationControllerClient interface { + Create(*v1.ReplicationController) (*v1.ReplicationController, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ReplicationController, error) + Update(*v1.ReplicationController) (*v1.ReplicationController, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ReplicationControllerList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ReplicationControllerClientCache + + OnCreate(ctx context.Context, name string, sync ReplicationControllerChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ReplicationControllerChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ReplicationControllerChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ReplicationControllerInterface +} + +type replicationControllerClientCache struct { + client *replicationControllerClient2 +} + +type replicationControllerClient2 struct { + iface ReplicationControllerInterface + controller ReplicationControllerController +} + +func (n *replicationControllerClient2) Interface() ReplicationControllerInterface { + return n.iface +} + +func (n *replicationControllerClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *replicationControllerClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *replicationControllerClient2) Create(obj *v1.ReplicationController) (*v1.ReplicationController, error) { + return n.iface.Create(obj) +} + +func (n *replicationControllerClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ReplicationController, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *replicationControllerClient2) Update(obj *v1.ReplicationController) (*v1.ReplicationController, error) { + return n.iface.Update(obj) +} + +func (n *replicationControllerClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *replicationControllerClient2) List(namespace string, opts metav1.ListOptions) (*ReplicationControllerList, error) { + return n.iface.List(opts) +} + +func (n *replicationControllerClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *replicationControllerClientCache) Get(namespace, name string) (*v1.ReplicationController, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *replicationControllerClientCache) List(namespace string, selector labels.Selector) ([]*v1.ReplicationController, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *replicationControllerClient2) Cache() ReplicationControllerClientCache { + n.loadController() + return &replicationControllerClientCache{ + client: n, + } +} + +func (n *replicationControllerClient2) OnCreate(ctx context.Context, name string, sync ReplicationControllerChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &replicationControllerLifecycleDelegate{create: sync}) +} + +func (n *replicationControllerClient2) OnChange(ctx context.Context, name string, sync ReplicationControllerChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &replicationControllerLifecycleDelegate{update: sync}) +} + +func (n *replicationControllerClient2) OnRemove(ctx context.Context, name string, sync ReplicationControllerChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &replicationControllerLifecycleDelegate{remove: sync}) +} + +func (n *replicationControllerClientCache) Index(name string, indexer ReplicationControllerIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ReplicationController); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *replicationControllerClientCache) GetIndexed(name, key string) ([]*v1.ReplicationController, error) { + var result []*v1.ReplicationController + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ReplicationController); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *replicationControllerClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type replicationControllerLifecycleDelegate struct { + create ReplicationControllerChangeHandlerFunc + update ReplicationControllerChangeHandlerFunc + remove ReplicationControllerChangeHandlerFunc +} + +func (n *replicationControllerLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *replicationControllerLifecycleDelegate) Create(obj *v1.ReplicationController) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *replicationControllerLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *replicationControllerLifecycleDelegate) Remove(obj *v1.ReplicationController) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *replicationControllerLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *replicationControllerLifecycleDelegate) Updated(obj *v1.ReplicationController) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_resource_quota_controller.go b/apis/core/v1/zz_generated_resource_quota_controller.go index 5b9dfe71..1c6a00ae 100644 --- a/apis/core/v1/zz_generated_resource_quota_controller.go +++ b/apis/core/v1/zz_generated_resource_quota_controller.go @@ -38,6 +38,8 @@ type ResourceQuotaList struct { type ResourceQuotaHandlerFunc func(key string, obj *v1.ResourceQuota) (runtime.Object, error) +type ResourceQuotaChangeHandlerFunc func(obj *v1.ResourceQuota) (runtime.Object, error) + type ResourceQuotaLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ResourceQuota, err error) Get(namespace, name string) (*v1.ResourceQuota, error) @@ -249,3 +251,182 @@ func (s *resourceQuotaClient) AddClusterScopedLifecycle(ctx context.Context, nam sync := NewResourceQuotaLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ResourceQuotaIndexer func(obj *v1.ResourceQuota) ([]string, error) + +type ResourceQuotaClientCache interface { + Get(namespace, name string) (*v1.ResourceQuota, error) + List(namespace string, selector labels.Selector) ([]*v1.ResourceQuota, error) + + Index(name string, indexer ResourceQuotaIndexer) + GetIndexed(name, key string) ([]*v1.ResourceQuota, error) +} + +type ResourceQuotaClient interface { + Create(*v1.ResourceQuota) (*v1.ResourceQuota, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ResourceQuota, error) + Update(*v1.ResourceQuota) (*v1.ResourceQuota, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ResourceQuotaList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ResourceQuotaClientCache + + OnCreate(ctx context.Context, name string, sync ResourceQuotaChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ResourceQuotaChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ResourceQuotaChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ResourceQuotaInterface +} + +type resourceQuotaClientCache struct { + client *resourceQuotaClient2 +} + +type resourceQuotaClient2 struct { + iface ResourceQuotaInterface + controller ResourceQuotaController +} + +func (n *resourceQuotaClient2) Interface() ResourceQuotaInterface { + return n.iface +} + +func (n *resourceQuotaClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *resourceQuotaClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *resourceQuotaClient2) Create(obj *v1.ResourceQuota) (*v1.ResourceQuota, error) { + return n.iface.Create(obj) +} + +func (n *resourceQuotaClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ResourceQuota, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *resourceQuotaClient2) Update(obj *v1.ResourceQuota) (*v1.ResourceQuota, error) { + return n.iface.Update(obj) +} + +func (n *resourceQuotaClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *resourceQuotaClient2) List(namespace string, opts metav1.ListOptions) (*ResourceQuotaList, error) { + return n.iface.List(opts) +} + +func (n *resourceQuotaClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *resourceQuotaClientCache) Get(namespace, name string) (*v1.ResourceQuota, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *resourceQuotaClientCache) List(namespace string, selector labels.Selector) ([]*v1.ResourceQuota, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *resourceQuotaClient2) Cache() ResourceQuotaClientCache { + n.loadController() + return &resourceQuotaClientCache{ + client: n, + } +} + +func (n *resourceQuotaClient2) OnCreate(ctx context.Context, name string, sync ResourceQuotaChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &resourceQuotaLifecycleDelegate{create: sync}) +} + +func (n *resourceQuotaClient2) OnChange(ctx context.Context, name string, sync ResourceQuotaChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &resourceQuotaLifecycleDelegate{update: sync}) +} + +func (n *resourceQuotaClient2) OnRemove(ctx context.Context, name string, sync ResourceQuotaChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &resourceQuotaLifecycleDelegate{remove: sync}) +} + +func (n *resourceQuotaClientCache) Index(name string, indexer ResourceQuotaIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ResourceQuota); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *resourceQuotaClientCache) GetIndexed(name, key string) ([]*v1.ResourceQuota, error) { + var result []*v1.ResourceQuota + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ResourceQuota); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *resourceQuotaClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type resourceQuotaLifecycleDelegate struct { + create ResourceQuotaChangeHandlerFunc + update ResourceQuotaChangeHandlerFunc + remove ResourceQuotaChangeHandlerFunc +} + +func (n *resourceQuotaLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *resourceQuotaLifecycleDelegate) Create(obj *v1.ResourceQuota) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *resourceQuotaLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *resourceQuotaLifecycleDelegate) Remove(obj *v1.ResourceQuota) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *resourceQuotaLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *resourceQuotaLifecycleDelegate) Updated(obj *v1.ResourceQuota) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_secret_controller.go b/apis/core/v1/zz_generated_secret_controller.go index 9e175087..b5954d3e 100644 --- a/apis/core/v1/zz_generated_secret_controller.go +++ b/apis/core/v1/zz_generated_secret_controller.go @@ -38,6 +38,8 @@ type SecretList struct { type SecretHandlerFunc func(key string, obj *v1.Secret) (runtime.Object, error) +type SecretChangeHandlerFunc func(obj *v1.Secret) (runtime.Object, error) + type SecretLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Secret, err error) Get(namespace, name string) (*v1.Secret, error) @@ -249,3 +251,182 @@ func (s *secretClient) AddClusterScopedLifecycle(ctx context.Context, name, clus sync := NewSecretLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SecretIndexer func(obj *v1.Secret) ([]string, error) + +type SecretClientCache interface { + Get(namespace, name string) (*v1.Secret, error) + List(namespace string, selector labels.Selector) ([]*v1.Secret, error) + + Index(name string, indexer SecretIndexer) + GetIndexed(name, key string) ([]*v1.Secret, error) +} + +type SecretClient interface { + Create(*v1.Secret) (*v1.Secret, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Secret, error) + Update(*v1.Secret) (*v1.Secret, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SecretList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SecretClientCache + + OnCreate(ctx context.Context, name string, sync SecretChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SecretChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SecretChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SecretInterface +} + +type secretClientCache struct { + client *secretClient2 +} + +type secretClient2 struct { + iface SecretInterface + controller SecretController +} + +func (n *secretClient2) Interface() SecretInterface { + return n.iface +} + +func (n *secretClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *secretClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *secretClient2) Create(obj *v1.Secret) (*v1.Secret, error) { + return n.iface.Create(obj) +} + +func (n *secretClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Secret, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *secretClient2) Update(obj *v1.Secret) (*v1.Secret, error) { + return n.iface.Update(obj) +} + +func (n *secretClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *secretClient2) List(namespace string, opts metav1.ListOptions) (*SecretList, error) { + return n.iface.List(opts) +} + +func (n *secretClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *secretClientCache) Get(namespace, name string) (*v1.Secret, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *secretClientCache) List(namespace string, selector labels.Selector) ([]*v1.Secret, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *secretClient2) Cache() SecretClientCache { + n.loadController() + return &secretClientCache{ + client: n, + } +} + +func (n *secretClient2) OnCreate(ctx context.Context, name string, sync SecretChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &secretLifecycleDelegate{create: sync}) +} + +func (n *secretClient2) OnChange(ctx context.Context, name string, sync SecretChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &secretLifecycleDelegate{update: sync}) +} + +func (n *secretClient2) OnRemove(ctx context.Context, name string, sync SecretChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &secretLifecycleDelegate{remove: sync}) +} + +func (n *secretClientCache) Index(name string, indexer SecretIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Secret); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *secretClientCache) GetIndexed(name, key string) ([]*v1.Secret, error) { + var result []*v1.Secret + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Secret); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *secretClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type secretLifecycleDelegate struct { + create SecretChangeHandlerFunc + update SecretChangeHandlerFunc + remove SecretChangeHandlerFunc +} + +func (n *secretLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *secretLifecycleDelegate) Create(obj *v1.Secret) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *secretLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *secretLifecycleDelegate) Remove(obj *v1.Secret) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *secretLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *secretLifecycleDelegate) Updated(obj *v1.Secret) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_service_account_controller.go b/apis/core/v1/zz_generated_service_account_controller.go index d4d93354..d8d3d14e 100644 --- a/apis/core/v1/zz_generated_service_account_controller.go +++ b/apis/core/v1/zz_generated_service_account_controller.go @@ -38,6 +38,8 @@ type ServiceAccountList struct { type ServiceAccountHandlerFunc func(key string, obj *v1.ServiceAccount) (runtime.Object, error) +type ServiceAccountChangeHandlerFunc func(obj *v1.ServiceAccount) (runtime.Object, error) + type ServiceAccountLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ServiceAccount, err error) Get(namespace, name string) (*v1.ServiceAccount, error) @@ -249,3 +251,182 @@ func (s *serviceAccountClient) AddClusterScopedLifecycle(ctx context.Context, na sync := NewServiceAccountLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ServiceAccountIndexer func(obj *v1.ServiceAccount) ([]string, error) + +type ServiceAccountClientCache interface { + Get(namespace, name string) (*v1.ServiceAccount, error) + List(namespace string, selector labels.Selector) ([]*v1.ServiceAccount, error) + + Index(name string, indexer ServiceAccountIndexer) + GetIndexed(name, key string) ([]*v1.ServiceAccount, error) +} + +type ServiceAccountClient interface { + Create(*v1.ServiceAccount) (*v1.ServiceAccount, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ServiceAccount, error) + Update(*v1.ServiceAccount) (*v1.ServiceAccount, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ServiceAccountList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ServiceAccountClientCache + + OnCreate(ctx context.Context, name string, sync ServiceAccountChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ServiceAccountChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ServiceAccountChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ServiceAccountInterface +} + +type serviceAccountClientCache struct { + client *serviceAccountClient2 +} + +type serviceAccountClient2 struct { + iface ServiceAccountInterface + controller ServiceAccountController +} + +func (n *serviceAccountClient2) Interface() ServiceAccountInterface { + return n.iface +} + +func (n *serviceAccountClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *serviceAccountClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *serviceAccountClient2) Create(obj *v1.ServiceAccount) (*v1.ServiceAccount, error) { + return n.iface.Create(obj) +} + +func (n *serviceAccountClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ServiceAccount, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *serviceAccountClient2) Update(obj *v1.ServiceAccount) (*v1.ServiceAccount, error) { + return n.iface.Update(obj) +} + +func (n *serviceAccountClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *serviceAccountClient2) List(namespace string, opts metav1.ListOptions) (*ServiceAccountList, error) { + return n.iface.List(opts) +} + +func (n *serviceAccountClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *serviceAccountClientCache) Get(namespace, name string) (*v1.ServiceAccount, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *serviceAccountClientCache) List(namespace string, selector labels.Selector) ([]*v1.ServiceAccount, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *serviceAccountClient2) Cache() ServiceAccountClientCache { + n.loadController() + return &serviceAccountClientCache{ + client: n, + } +} + +func (n *serviceAccountClient2) OnCreate(ctx context.Context, name string, sync ServiceAccountChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceAccountLifecycleDelegate{create: sync}) +} + +func (n *serviceAccountClient2) OnChange(ctx context.Context, name string, sync ServiceAccountChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceAccountLifecycleDelegate{update: sync}) +} + +func (n *serviceAccountClient2) OnRemove(ctx context.Context, name string, sync ServiceAccountChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceAccountLifecycleDelegate{remove: sync}) +} + +func (n *serviceAccountClientCache) Index(name string, indexer ServiceAccountIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ServiceAccount); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *serviceAccountClientCache) GetIndexed(name, key string) ([]*v1.ServiceAccount, error) { + var result []*v1.ServiceAccount + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ServiceAccount); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *serviceAccountClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type serviceAccountLifecycleDelegate struct { + create ServiceAccountChangeHandlerFunc + update ServiceAccountChangeHandlerFunc + remove ServiceAccountChangeHandlerFunc +} + +func (n *serviceAccountLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *serviceAccountLifecycleDelegate) Create(obj *v1.ServiceAccount) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *serviceAccountLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *serviceAccountLifecycleDelegate) Remove(obj *v1.ServiceAccount) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *serviceAccountLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *serviceAccountLifecycleDelegate) Updated(obj *v1.ServiceAccount) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/core/v1/zz_generated_service_controller.go b/apis/core/v1/zz_generated_service_controller.go index f4c1726c..ba67878b 100644 --- a/apis/core/v1/zz_generated_service_controller.go +++ b/apis/core/v1/zz_generated_service_controller.go @@ -38,6 +38,8 @@ type ServiceList struct { type ServiceHandlerFunc func(key string, obj *v1.Service) (runtime.Object, error) +type ServiceChangeHandlerFunc func(obj *v1.Service) (runtime.Object, error) + type ServiceLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Service, err error) Get(namespace, name string) (*v1.Service, error) @@ -249,3 +251,182 @@ func (s *serviceClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewServiceLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ServiceIndexer func(obj *v1.Service) ([]string, error) + +type ServiceClientCache interface { + Get(namespace, name string) (*v1.Service, error) + List(namespace string, selector labels.Selector) ([]*v1.Service, error) + + Index(name string, indexer ServiceIndexer) + GetIndexed(name, key string) ([]*v1.Service, error) +} + +type ServiceClient interface { + Create(*v1.Service) (*v1.Service, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Service, error) + Update(*v1.Service) (*v1.Service, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ServiceList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ServiceClientCache + + OnCreate(ctx context.Context, name string, sync ServiceChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ServiceChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ServiceChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ServiceInterface +} + +type serviceClientCache struct { + client *serviceClient2 +} + +type serviceClient2 struct { + iface ServiceInterface + controller ServiceController +} + +func (n *serviceClient2) Interface() ServiceInterface { + return n.iface +} + +func (n *serviceClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *serviceClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *serviceClient2) Create(obj *v1.Service) (*v1.Service, error) { + return n.iface.Create(obj) +} + +func (n *serviceClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Service, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *serviceClient2) Update(obj *v1.Service) (*v1.Service, error) { + return n.iface.Update(obj) +} + +func (n *serviceClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *serviceClient2) List(namespace string, opts metav1.ListOptions) (*ServiceList, error) { + return n.iface.List(opts) +} + +func (n *serviceClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *serviceClientCache) Get(namespace, name string) (*v1.Service, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *serviceClientCache) List(namespace string, selector labels.Selector) ([]*v1.Service, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *serviceClient2) Cache() ServiceClientCache { + n.loadController() + return &serviceClientCache{ + client: n, + } +} + +func (n *serviceClient2) OnCreate(ctx context.Context, name string, sync ServiceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceLifecycleDelegate{create: sync}) +} + +func (n *serviceClient2) OnChange(ctx context.Context, name string, sync ServiceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceLifecycleDelegate{update: sync}) +} + +func (n *serviceClient2) OnRemove(ctx context.Context, name string, sync ServiceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceLifecycleDelegate{remove: sync}) +} + +func (n *serviceClientCache) Index(name string, indexer ServiceIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Service); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *serviceClientCache) GetIndexed(name, key string) ([]*v1.Service, error) { + var result []*v1.Service + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Service); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *serviceClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type serviceLifecycleDelegate struct { + create ServiceChangeHandlerFunc + update ServiceChangeHandlerFunc + remove ServiceChangeHandlerFunc +} + +func (n *serviceLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *serviceLifecycleDelegate) Create(obj *v1.Service) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *serviceLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *serviceLifecycleDelegate) Remove(obj *v1.Service) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *serviceLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *serviceLifecycleDelegate) Updated(obj *v1.Service) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/extensions/v1beta1/zz_generated_ingress_controller.go b/apis/extensions/v1beta1/zz_generated_ingress_controller.go index 2dabb2d1..108bcd04 100644 --- a/apis/extensions/v1beta1/zz_generated_ingress_controller.go +++ b/apis/extensions/v1beta1/zz_generated_ingress_controller.go @@ -38,6 +38,8 @@ type IngressList struct { type IngressHandlerFunc func(key string, obj *v1beta1.Ingress) (runtime.Object, error) +type IngressChangeHandlerFunc func(obj *v1beta1.Ingress) (runtime.Object, error) + type IngressLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta1.Ingress, err error) Get(namespace, name string) (*v1beta1.Ingress, error) @@ -249,3 +251,182 @@ func (s *ingressClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewIngressLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type IngressIndexer func(obj *v1beta1.Ingress) ([]string, error) + +type IngressClientCache interface { + Get(namespace, name string) (*v1beta1.Ingress, error) + List(namespace string, selector labels.Selector) ([]*v1beta1.Ingress, error) + + Index(name string, indexer IngressIndexer) + GetIndexed(name, key string) ([]*v1beta1.Ingress, error) +} + +type IngressClient interface { + Create(*v1beta1.Ingress) (*v1beta1.Ingress, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta1.Ingress, error) + Update(*v1beta1.Ingress) (*v1beta1.Ingress, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*IngressList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() IngressClientCache + + OnCreate(ctx context.Context, name string, sync IngressChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync IngressChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync IngressChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() IngressInterface +} + +type ingressClientCache struct { + client *ingressClient2 +} + +type ingressClient2 struct { + iface IngressInterface + controller IngressController +} + +func (n *ingressClient2) Interface() IngressInterface { + return n.iface +} + +func (n *ingressClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *ingressClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *ingressClient2) Create(obj *v1beta1.Ingress) (*v1beta1.Ingress, error) { + return n.iface.Create(obj) +} + +func (n *ingressClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta1.Ingress, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *ingressClient2) Update(obj *v1beta1.Ingress) (*v1beta1.Ingress, error) { + return n.iface.Update(obj) +} + +func (n *ingressClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *ingressClient2) List(namespace string, opts metav1.ListOptions) (*IngressList, error) { + return n.iface.List(opts) +} + +func (n *ingressClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *ingressClientCache) Get(namespace, name string) (*v1beta1.Ingress, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *ingressClientCache) List(namespace string, selector labels.Selector) ([]*v1beta1.Ingress, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *ingressClient2) Cache() IngressClientCache { + n.loadController() + return &ingressClientCache{ + client: n, + } +} + +func (n *ingressClient2) OnCreate(ctx context.Context, name string, sync IngressChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &ingressLifecycleDelegate{create: sync}) +} + +func (n *ingressClient2) OnChange(ctx context.Context, name string, sync IngressChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &ingressLifecycleDelegate{update: sync}) +} + +func (n *ingressClient2) OnRemove(ctx context.Context, name string, sync IngressChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &ingressLifecycleDelegate{remove: sync}) +} + +func (n *ingressClientCache) Index(name string, indexer IngressIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta1.Ingress); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *ingressClientCache) GetIndexed(name, key string) ([]*v1beta1.Ingress, error) { + var result []*v1beta1.Ingress + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta1.Ingress); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *ingressClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type ingressLifecycleDelegate struct { + create IngressChangeHandlerFunc + update IngressChangeHandlerFunc + remove IngressChangeHandlerFunc +} + +func (n *ingressLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *ingressLifecycleDelegate) Create(obj *v1beta1.Ingress) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *ingressLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *ingressLifecycleDelegate) Remove(obj *v1beta1.Ingress) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *ingressLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *ingressLifecycleDelegate) Updated(obj *v1beta1.Ingress) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/extensions/v1beta1/zz_generated_k8s_client.go b/apis/extensions/v1beta1/zz_generated_k8s_client.go index 02121b62..aa837622 100644 --- a/apis/extensions/v1beta1/zz_generated_k8s_client.go +++ b/apis/extensions/v1beta1/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -21,6 +24,11 @@ type Interface interface { IngressesGetter } +type Clients struct { + PodSecurityPolicy PodSecurityPolicyClient + Ingress IngressClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -36,13 +44,41 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + PodSecurityPolicy: &podSecurityPolicyClient2{ + iface: iface.PodSecurityPolicies(""), + }, + Ingress: &ingressClient2{ + iface: iface.Ingresses(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/extensions/v1beta1/zz_generated_pod_security_policy_controller.go b/apis/extensions/v1beta1/zz_generated_pod_security_policy_controller.go index 080ecfb3..e75a9141 100644 --- a/apis/extensions/v1beta1/zz_generated_pod_security_policy_controller.go +++ b/apis/extensions/v1beta1/zz_generated_pod_security_policy_controller.go @@ -37,6 +37,8 @@ type PodSecurityPolicyList struct { type PodSecurityPolicyHandlerFunc func(key string, obj *v1beta1.PodSecurityPolicy) (runtime.Object, error) +type PodSecurityPolicyChangeHandlerFunc func(obj *v1beta1.PodSecurityPolicy) (runtime.Object, error) + type PodSecurityPolicyLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta1.PodSecurityPolicy, err error) Get(namespace, name string) (*v1beta1.PodSecurityPolicy, error) @@ -248,3 +250,182 @@ func (s *podSecurityPolicyClient) AddClusterScopedLifecycle(ctx context.Context, sync := NewPodSecurityPolicyLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PodSecurityPolicyIndexer func(obj *v1beta1.PodSecurityPolicy) ([]string, error) + +type PodSecurityPolicyClientCache interface { + Get(namespace, name string) (*v1beta1.PodSecurityPolicy, error) + List(namespace string, selector labels.Selector) ([]*v1beta1.PodSecurityPolicy, error) + + Index(name string, indexer PodSecurityPolicyIndexer) + GetIndexed(name, key string) ([]*v1beta1.PodSecurityPolicy, error) +} + +type PodSecurityPolicyClient interface { + Create(*v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1beta1.PodSecurityPolicy, error) + Update(*v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PodSecurityPolicyClientCache + + OnCreate(ctx context.Context, name string, sync PodSecurityPolicyChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PodSecurityPolicyChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PodSecurityPolicyChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PodSecurityPolicyInterface +} + +type podSecurityPolicyClientCache struct { + client *podSecurityPolicyClient2 +} + +type podSecurityPolicyClient2 struct { + iface PodSecurityPolicyInterface + controller PodSecurityPolicyController +} + +func (n *podSecurityPolicyClient2) Interface() PodSecurityPolicyInterface { + return n.iface +} + +func (n *podSecurityPolicyClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *podSecurityPolicyClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *podSecurityPolicyClient2) Create(obj *v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error) { + return n.iface.Create(obj) +} + +func (n *podSecurityPolicyClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1beta1.PodSecurityPolicy, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *podSecurityPolicyClient2) Update(obj *v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error) { + return n.iface.Update(obj) +} + +func (n *podSecurityPolicyClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *podSecurityPolicyClient2) List(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyList, error) { + return n.iface.List(opts) +} + +func (n *podSecurityPolicyClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *podSecurityPolicyClientCache) Get(namespace, name string) (*v1beta1.PodSecurityPolicy, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *podSecurityPolicyClientCache) List(namespace string, selector labels.Selector) ([]*v1beta1.PodSecurityPolicy, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *podSecurityPolicyClient2) Cache() PodSecurityPolicyClientCache { + n.loadController() + return &podSecurityPolicyClientCache{ + client: n, + } +} + +func (n *podSecurityPolicyClient2) OnCreate(ctx context.Context, name string, sync PodSecurityPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyLifecycleDelegate{create: sync}) +} + +func (n *podSecurityPolicyClient2) OnChange(ctx context.Context, name string, sync PodSecurityPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyLifecycleDelegate{update: sync}) +} + +func (n *podSecurityPolicyClient2) OnRemove(ctx context.Context, name string, sync PodSecurityPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyLifecycleDelegate{remove: sync}) +} + +func (n *podSecurityPolicyClientCache) Index(name string, indexer PodSecurityPolicyIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1beta1.PodSecurityPolicy); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *podSecurityPolicyClientCache) GetIndexed(name, key string) ([]*v1beta1.PodSecurityPolicy, error) { + var result []*v1beta1.PodSecurityPolicy + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1beta1.PodSecurityPolicy); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *podSecurityPolicyClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type podSecurityPolicyLifecycleDelegate struct { + create PodSecurityPolicyChangeHandlerFunc + update PodSecurityPolicyChangeHandlerFunc + remove PodSecurityPolicyChangeHandlerFunc +} + +func (n *podSecurityPolicyLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *podSecurityPolicyLifecycleDelegate) Create(obj *v1beta1.PodSecurityPolicy) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *podSecurityPolicyLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *podSecurityPolicyLifecycleDelegate) Remove(obj *v1beta1.PodSecurityPolicy) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *podSecurityPolicyLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *podSecurityPolicyLifecycleDelegate) Updated(obj *v1beta1.PodSecurityPolicy) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_auth_config_controller.go b/apis/management.cattle.io/v3/zz_generated_auth_config_controller.go index 79b549d0..c69397b2 100644 --- a/apis/management.cattle.io/v3/zz_generated_auth_config_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_auth_config_controller.go @@ -36,6 +36,8 @@ type AuthConfigList struct { type AuthConfigHandlerFunc func(key string, obj *AuthConfig) (runtime.Object, error) +type AuthConfigChangeHandlerFunc func(obj *AuthConfig) (runtime.Object, error) + type AuthConfigLister interface { List(namespace string, selector labels.Selector) (ret []*AuthConfig, err error) Get(namespace, name string) (*AuthConfig, error) @@ -247,3 +249,182 @@ func (s *authConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewAuthConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type AuthConfigIndexer func(obj *AuthConfig) ([]string, error) + +type AuthConfigClientCache interface { + Get(namespace, name string) (*AuthConfig, error) + List(namespace string, selector labels.Selector) ([]*AuthConfig, error) + + Index(name string, indexer AuthConfigIndexer) + GetIndexed(name, key string) ([]*AuthConfig, error) +} + +type AuthConfigClient interface { + Create(*AuthConfig) (*AuthConfig, error) + Get(namespace, name string, opts metav1.GetOptions) (*AuthConfig, error) + Update(*AuthConfig) (*AuthConfig, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*AuthConfigList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() AuthConfigClientCache + + OnCreate(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() AuthConfigInterface +} + +type authConfigClientCache struct { + client *authConfigClient2 +} + +type authConfigClient2 struct { + iface AuthConfigInterface + controller AuthConfigController +} + +func (n *authConfigClient2) Interface() AuthConfigInterface { + return n.iface +} + +func (n *authConfigClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *authConfigClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *authConfigClient2) Create(obj *AuthConfig) (*AuthConfig, error) { + return n.iface.Create(obj) +} + +func (n *authConfigClient2) Get(namespace, name string, opts metav1.GetOptions) (*AuthConfig, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *authConfigClient2) Update(obj *AuthConfig) (*AuthConfig, error) { + return n.iface.Update(obj) +} + +func (n *authConfigClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *authConfigClient2) List(namespace string, opts metav1.ListOptions) (*AuthConfigList, error) { + return n.iface.List(opts) +} + +func (n *authConfigClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *authConfigClientCache) Get(namespace, name string) (*AuthConfig, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *authConfigClientCache) List(namespace string, selector labels.Selector) ([]*AuthConfig, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *authConfigClient2) Cache() AuthConfigClientCache { + n.loadController() + return &authConfigClientCache{ + client: n, + } +} + +func (n *authConfigClient2) OnCreate(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &authConfigLifecycleDelegate{create: sync}) +} + +func (n *authConfigClient2) OnChange(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &authConfigLifecycleDelegate{update: sync}) +} + +func (n *authConfigClient2) OnRemove(ctx context.Context, name string, sync AuthConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &authConfigLifecycleDelegate{remove: sync}) +} + +func (n *authConfigClientCache) Index(name string, indexer AuthConfigIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*AuthConfig); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *authConfigClientCache) GetIndexed(name, key string) ([]*AuthConfig, error) { + var result []*AuthConfig + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*AuthConfig); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *authConfigClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type authConfigLifecycleDelegate struct { + create AuthConfigChangeHandlerFunc + update AuthConfigChangeHandlerFunc + remove AuthConfigChangeHandlerFunc +} + +func (n *authConfigLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *authConfigLifecycleDelegate) Create(obj *AuthConfig) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *authConfigLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *authConfigLifecycleDelegate) Remove(obj *AuthConfig) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *authConfigLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *authConfigLifecycleDelegate) Updated(obj *AuthConfig) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_catalog_controller.go b/apis/management.cattle.io/v3/zz_generated_catalog_controller.go index 3684a9d4..47277c8f 100644 --- a/apis/management.cattle.io/v3/zz_generated_catalog_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_catalog_controller.go @@ -36,6 +36,8 @@ type CatalogList struct { type CatalogHandlerFunc func(key string, obj *Catalog) (runtime.Object, error) +type CatalogChangeHandlerFunc func(obj *Catalog) (runtime.Object, error) + type CatalogLister interface { List(namespace string, selector labels.Selector) (ret []*Catalog, err error) Get(namespace, name string) (*Catalog, error) @@ -247,3 +249,182 @@ func (s *catalogClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewCatalogLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type CatalogIndexer func(obj *Catalog) ([]string, error) + +type CatalogClientCache interface { + Get(namespace, name string) (*Catalog, error) + List(namespace string, selector labels.Selector) ([]*Catalog, error) + + Index(name string, indexer CatalogIndexer) + GetIndexed(name, key string) ([]*Catalog, error) +} + +type CatalogClient interface { + Create(*Catalog) (*Catalog, error) + Get(namespace, name string, opts metav1.GetOptions) (*Catalog, error) + Update(*Catalog) (*Catalog, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*CatalogList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() CatalogClientCache + + OnCreate(ctx context.Context, name string, sync CatalogChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync CatalogChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync CatalogChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() CatalogInterface +} + +type catalogClientCache struct { + client *catalogClient2 +} + +type catalogClient2 struct { + iface CatalogInterface + controller CatalogController +} + +func (n *catalogClient2) Interface() CatalogInterface { + return n.iface +} + +func (n *catalogClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *catalogClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *catalogClient2) Create(obj *Catalog) (*Catalog, error) { + return n.iface.Create(obj) +} + +func (n *catalogClient2) Get(namespace, name string, opts metav1.GetOptions) (*Catalog, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *catalogClient2) Update(obj *Catalog) (*Catalog, error) { + return n.iface.Update(obj) +} + +func (n *catalogClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *catalogClient2) List(namespace string, opts metav1.ListOptions) (*CatalogList, error) { + return n.iface.List(opts) +} + +func (n *catalogClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *catalogClientCache) Get(namespace, name string) (*Catalog, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *catalogClientCache) List(namespace string, selector labels.Selector) ([]*Catalog, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *catalogClient2) Cache() CatalogClientCache { + n.loadController() + return &catalogClientCache{ + client: n, + } +} + +func (n *catalogClient2) OnCreate(ctx context.Context, name string, sync CatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &catalogLifecycleDelegate{create: sync}) +} + +func (n *catalogClient2) OnChange(ctx context.Context, name string, sync CatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &catalogLifecycleDelegate{update: sync}) +} + +func (n *catalogClient2) OnRemove(ctx context.Context, name string, sync CatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &catalogLifecycleDelegate{remove: sync}) +} + +func (n *catalogClientCache) Index(name string, indexer CatalogIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Catalog); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *catalogClientCache) GetIndexed(name, key string) ([]*Catalog, error) { + var result []*Catalog + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Catalog); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *catalogClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type catalogLifecycleDelegate struct { + create CatalogChangeHandlerFunc + update CatalogChangeHandlerFunc + remove CatalogChangeHandlerFunc +} + +func (n *catalogLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *catalogLifecycleDelegate) Create(obj *Catalog) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *catalogLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *catalogLifecycleDelegate) Remove(obj *Catalog) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *catalogLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *catalogLifecycleDelegate) Updated(obj *Catalog) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_alert_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_alert_controller.go index e2fdbd55..a3c8f5c8 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_alert_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_alert_controller.go @@ -37,6 +37,8 @@ type ClusterAlertList struct { type ClusterAlertHandlerFunc func(key string, obj *ClusterAlert) (runtime.Object, error) +type ClusterAlertChangeHandlerFunc func(obj *ClusterAlert) (runtime.Object, error) + type ClusterAlertLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterAlert, err error) Get(namespace, name string) (*ClusterAlert, error) @@ -248,3 +250,182 @@ func (s *clusterAlertClient) AddClusterScopedLifecycle(ctx context.Context, name sync := NewClusterAlertLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterAlertIndexer func(obj *ClusterAlert) ([]string, error) + +type ClusterAlertClientCache interface { + Get(namespace, name string) (*ClusterAlert, error) + List(namespace string, selector labels.Selector) ([]*ClusterAlert, error) + + Index(name string, indexer ClusterAlertIndexer) + GetIndexed(name, key string) ([]*ClusterAlert, error) +} + +type ClusterAlertClient interface { + Create(*ClusterAlert) (*ClusterAlert, error) + Get(namespace, name string, opts metav1.GetOptions) (*ClusterAlert, error) + Update(*ClusterAlert) (*ClusterAlert, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterAlertList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterAlertClientCache + + OnCreate(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterAlertInterface +} + +type clusterAlertClientCache struct { + client *clusterAlertClient2 +} + +type clusterAlertClient2 struct { + iface ClusterAlertInterface + controller ClusterAlertController +} + +func (n *clusterAlertClient2) Interface() ClusterAlertInterface { + return n.iface +} + +func (n *clusterAlertClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterAlertClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterAlertClient2) Create(obj *ClusterAlert) (*ClusterAlert, error) { + return n.iface.Create(obj) +} + +func (n *clusterAlertClient2) Get(namespace, name string, opts metav1.GetOptions) (*ClusterAlert, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterAlertClient2) Update(obj *ClusterAlert) (*ClusterAlert, error) { + return n.iface.Update(obj) +} + +func (n *clusterAlertClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterAlertClient2) List(namespace string, opts metav1.ListOptions) (*ClusterAlertList, error) { + return n.iface.List(opts) +} + +func (n *clusterAlertClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterAlertClientCache) Get(namespace, name string) (*ClusterAlert, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterAlertClientCache) List(namespace string, selector labels.Selector) ([]*ClusterAlert, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterAlertClient2) Cache() ClusterAlertClientCache { + n.loadController() + return &clusterAlertClientCache{ + client: n, + } +} + +func (n *clusterAlertClient2) OnCreate(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterAlertLifecycleDelegate{create: sync}) +} + +func (n *clusterAlertClient2) OnChange(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterAlertLifecycleDelegate{update: sync}) +} + +func (n *clusterAlertClient2) OnRemove(ctx context.Context, name string, sync ClusterAlertChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterAlertLifecycleDelegate{remove: sync}) +} + +func (n *clusterAlertClientCache) Index(name string, indexer ClusterAlertIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ClusterAlert); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterAlertClientCache) GetIndexed(name, key string) ([]*ClusterAlert, error) { + var result []*ClusterAlert + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ClusterAlert); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterAlertClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterAlertLifecycleDelegate struct { + create ClusterAlertChangeHandlerFunc + update ClusterAlertChangeHandlerFunc + remove ClusterAlertChangeHandlerFunc +} + +func (n *clusterAlertLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterAlertLifecycleDelegate) Create(obj *ClusterAlert) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterAlertLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterAlertLifecycleDelegate) Remove(obj *ClusterAlert) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterAlertLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterAlertLifecycleDelegate) Updated(obj *ClusterAlert) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_catalog_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_catalog_controller.go index 2cc199f7..d3d1aa6f 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_catalog_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_catalog_controller.go @@ -37,6 +37,8 @@ type ClusterCatalogList struct { type ClusterCatalogHandlerFunc func(key string, obj *ClusterCatalog) (runtime.Object, error) +type ClusterCatalogChangeHandlerFunc func(obj *ClusterCatalog) (runtime.Object, error) + type ClusterCatalogLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterCatalog, err error) Get(namespace, name string) (*ClusterCatalog, error) @@ -248,3 +250,182 @@ func (s *clusterCatalogClient) AddClusterScopedLifecycle(ctx context.Context, na sync := NewClusterCatalogLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterCatalogIndexer func(obj *ClusterCatalog) ([]string, error) + +type ClusterCatalogClientCache interface { + Get(namespace, name string) (*ClusterCatalog, error) + List(namespace string, selector labels.Selector) ([]*ClusterCatalog, error) + + Index(name string, indexer ClusterCatalogIndexer) + GetIndexed(name, key string) ([]*ClusterCatalog, error) +} + +type ClusterCatalogClient interface { + Create(*ClusterCatalog) (*ClusterCatalog, error) + Get(namespace, name string, opts metav1.GetOptions) (*ClusterCatalog, error) + Update(*ClusterCatalog) (*ClusterCatalog, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterCatalogList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterCatalogClientCache + + OnCreate(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterCatalogInterface +} + +type clusterCatalogClientCache struct { + client *clusterCatalogClient2 +} + +type clusterCatalogClient2 struct { + iface ClusterCatalogInterface + controller ClusterCatalogController +} + +func (n *clusterCatalogClient2) Interface() ClusterCatalogInterface { + return n.iface +} + +func (n *clusterCatalogClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterCatalogClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterCatalogClient2) Create(obj *ClusterCatalog) (*ClusterCatalog, error) { + return n.iface.Create(obj) +} + +func (n *clusterCatalogClient2) Get(namespace, name string, opts metav1.GetOptions) (*ClusterCatalog, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterCatalogClient2) Update(obj *ClusterCatalog) (*ClusterCatalog, error) { + return n.iface.Update(obj) +} + +func (n *clusterCatalogClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterCatalogClient2) List(namespace string, opts metav1.ListOptions) (*ClusterCatalogList, error) { + return n.iface.List(opts) +} + +func (n *clusterCatalogClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterCatalogClientCache) Get(namespace, name string) (*ClusterCatalog, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterCatalogClientCache) List(namespace string, selector labels.Selector) ([]*ClusterCatalog, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterCatalogClient2) Cache() ClusterCatalogClientCache { + n.loadController() + return &clusterCatalogClientCache{ + client: n, + } +} + +func (n *clusterCatalogClient2) OnCreate(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterCatalogLifecycleDelegate{create: sync}) +} + +func (n *clusterCatalogClient2) OnChange(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterCatalogLifecycleDelegate{update: sync}) +} + +func (n *clusterCatalogClient2) OnRemove(ctx context.Context, name string, sync ClusterCatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterCatalogLifecycleDelegate{remove: sync}) +} + +func (n *clusterCatalogClientCache) Index(name string, indexer ClusterCatalogIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ClusterCatalog); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterCatalogClientCache) GetIndexed(name, key string) ([]*ClusterCatalog, error) { + var result []*ClusterCatalog + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ClusterCatalog); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterCatalogClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterCatalogLifecycleDelegate struct { + create ClusterCatalogChangeHandlerFunc + update ClusterCatalogChangeHandlerFunc + remove ClusterCatalogChangeHandlerFunc +} + +func (n *clusterCatalogLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterCatalogLifecycleDelegate) Create(obj *ClusterCatalog) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterCatalogLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterCatalogLifecycleDelegate) Remove(obj *ClusterCatalog) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterCatalogLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterCatalogLifecycleDelegate) Updated(obj *ClusterCatalog) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_controller.go index 9ba8ca3f..41a439bf 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_controller.go @@ -36,6 +36,8 @@ type ClusterList struct { type ClusterHandlerFunc func(key string, obj *Cluster) (runtime.Object, error) +type ClusterChangeHandlerFunc func(obj *Cluster) (runtime.Object, error) + type ClusterLister interface { List(namespace string, selector labels.Selector) (ret []*Cluster, err error) Get(namespace, name string) (*Cluster, error) @@ -247,3 +249,182 @@ func (s *clusterClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewClusterLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterIndexer func(obj *Cluster) ([]string, error) + +type ClusterClientCache interface { + Get(namespace, name string) (*Cluster, error) + List(namespace string, selector labels.Selector) ([]*Cluster, error) + + Index(name string, indexer ClusterIndexer) + GetIndexed(name, key string) ([]*Cluster, error) +} + +type ClusterClient interface { + Create(*Cluster) (*Cluster, error) + Get(namespace, name string, opts metav1.GetOptions) (*Cluster, error) + Update(*Cluster) (*Cluster, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterClientCache + + OnCreate(ctx context.Context, name string, sync ClusterChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterInterface +} + +type clusterClientCache struct { + client *clusterClient2 +} + +type clusterClient2 struct { + iface ClusterInterface + controller ClusterController +} + +func (n *clusterClient2) Interface() ClusterInterface { + return n.iface +} + +func (n *clusterClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterClient2) Create(obj *Cluster) (*Cluster, error) { + return n.iface.Create(obj) +} + +func (n *clusterClient2) Get(namespace, name string, opts metav1.GetOptions) (*Cluster, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterClient2) Update(obj *Cluster) (*Cluster, error) { + return n.iface.Update(obj) +} + +func (n *clusterClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterClient2) List(namespace string, opts metav1.ListOptions) (*ClusterList, error) { + return n.iface.List(opts) +} + +func (n *clusterClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterClientCache) Get(namespace, name string) (*Cluster, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterClientCache) List(namespace string, selector labels.Selector) ([]*Cluster, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterClient2) Cache() ClusterClientCache { + n.loadController() + return &clusterClientCache{ + client: n, + } +} + +func (n *clusterClient2) OnCreate(ctx context.Context, name string, sync ClusterChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterLifecycleDelegate{create: sync}) +} + +func (n *clusterClient2) OnChange(ctx context.Context, name string, sync ClusterChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterLifecycleDelegate{update: sync}) +} + +func (n *clusterClient2) OnRemove(ctx context.Context, name string, sync ClusterChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterLifecycleDelegate{remove: sync}) +} + +func (n *clusterClientCache) Index(name string, indexer ClusterIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Cluster); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterClientCache) GetIndexed(name, key string) ([]*Cluster, error) { + var result []*Cluster + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Cluster); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterLifecycleDelegate struct { + create ClusterChangeHandlerFunc + update ClusterChangeHandlerFunc + remove ClusterChangeHandlerFunc +} + +func (n *clusterLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterLifecycleDelegate) Create(obj *Cluster) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterLifecycleDelegate) Remove(obj *Cluster) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterLifecycleDelegate) Updated(obj *Cluster) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_logging_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_logging_controller.go index f9c98299..305c65e5 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_logging_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_logging_controller.go @@ -37,6 +37,8 @@ type ClusterLoggingList struct { type ClusterLoggingHandlerFunc func(key string, obj *ClusterLogging) (runtime.Object, error) +type ClusterLoggingChangeHandlerFunc func(obj *ClusterLogging) (runtime.Object, error) + type ClusterLoggingLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterLogging, err error) Get(namespace, name string) (*ClusterLogging, error) @@ -248,3 +250,182 @@ func (s *clusterLoggingClient) AddClusterScopedLifecycle(ctx context.Context, na sync := NewClusterLoggingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterLoggingIndexer func(obj *ClusterLogging) ([]string, error) + +type ClusterLoggingClientCache interface { + Get(namespace, name string) (*ClusterLogging, error) + List(namespace string, selector labels.Selector) ([]*ClusterLogging, error) + + Index(name string, indexer ClusterLoggingIndexer) + GetIndexed(name, key string) ([]*ClusterLogging, error) +} + +type ClusterLoggingClient interface { + Create(*ClusterLogging) (*ClusterLogging, error) + Get(namespace, name string, opts metav1.GetOptions) (*ClusterLogging, error) + Update(*ClusterLogging) (*ClusterLogging, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterLoggingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterLoggingClientCache + + OnCreate(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterLoggingInterface +} + +type clusterLoggingClientCache struct { + client *clusterLoggingClient2 +} + +type clusterLoggingClient2 struct { + iface ClusterLoggingInterface + controller ClusterLoggingController +} + +func (n *clusterLoggingClient2) Interface() ClusterLoggingInterface { + return n.iface +} + +func (n *clusterLoggingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterLoggingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterLoggingClient2) Create(obj *ClusterLogging) (*ClusterLogging, error) { + return n.iface.Create(obj) +} + +func (n *clusterLoggingClient2) Get(namespace, name string, opts metav1.GetOptions) (*ClusterLogging, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterLoggingClient2) Update(obj *ClusterLogging) (*ClusterLogging, error) { + return n.iface.Update(obj) +} + +func (n *clusterLoggingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterLoggingClient2) List(namespace string, opts metav1.ListOptions) (*ClusterLoggingList, error) { + return n.iface.List(opts) +} + +func (n *clusterLoggingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterLoggingClientCache) Get(namespace, name string) (*ClusterLogging, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterLoggingClientCache) List(namespace string, selector labels.Selector) ([]*ClusterLogging, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterLoggingClient2) Cache() ClusterLoggingClientCache { + n.loadController() + return &clusterLoggingClientCache{ + client: n, + } +} + +func (n *clusterLoggingClient2) OnCreate(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterLoggingLifecycleDelegate{create: sync}) +} + +func (n *clusterLoggingClient2) OnChange(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterLoggingLifecycleDelegate{update: sync}) +} + +func (n *clusterLoggingClient2) OnRemove(ctx context.Context, name string, sync ClusterLoggingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterLoggingLifecycleDelegate{remove: sync}) +} + +func (n *clusterLoggingClientCache) Index(name string, indexer ClusterLoggingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ClusterLogging); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterLoggingClientCache) GetIndexed(name, key string) ([]*ClusterLogging, error) { + var result []*ClusterLogging + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ClusterLogging); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterLoggingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterLoggingLifecycleDelegate struct { + create ClusterLoggingChangeHandlerFunc + update ClusterLoggingChangeHandlerFunc + remove ClusterLoggingChangeHandlerFunc +} + +func (n *clusterLoggingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterLoggingLifecycleDelegate) Create(obj *ClusterLogging) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterLoggingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterLoggingLifecycleDelegate) Remove(obj *ClusterLogging) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterLoggingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterLoggingLifecycleDelegate) Updated(obj *ClusterLogging) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_controller.go index 007381b4..8acc68b2 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_controller.go @@ -37,6 +37,8 @@ type ClusterRegistrationTokenList struct { type ClusterRegistrationTokenHandlerFunc func(key string, obj *ClusterRegistrationToken) (runtime.Object, error) +type ClusterRegistrationTokenChangeHandlerFunc func(obj *ClusterRegistrationToken) (runtime.Object, error) + type ClusterRegistrationTokenLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterRegistrationToken, err error) Get(namespace, name string) (*ClusterRegistrationToken, error) @@ -248,3 +250,182 @@ func (s *clusterRegistrationTokenClient) AddClusterScopedLifecycle(ctx context.C sync := NewClusterRegistrationTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterRegistrationTokenIndexer func(obj *ClusterRegistrationToken) ([]string, error) + +type ClusterRegistrationTokenClientCache interface { + Get(namespace, name string) (*ClusterRegistrationToken, error) + List(namespace string, selector labels.Selector) ([]*ClusterRegistrationToken, error) + + Index(name string, indexer ClusterRegistrationTokenIndexer) + GetIndexed(name, key string) ([]*ClusterRegistrationToken, error) +} + +type ClusterRegistrationTokenClient interface { + Create(*ClusterRegistrationToken) (*ClusterRegistrationToken, error) + Get(namespace, name string, opts metav1.GetOptions) (*ClusterRegistrationToken, error) + Update(*ClusterRegistrationToken) (*ClusterRegistrationToken, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterRegistrationTokenList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterRegistrationTokenClientCache + + OnCreate(ctx context.Context, name string, sync ClusterRegistrationTokenChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterRegistrationTokenChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterRegistrationTokenChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterRegistrationTokenInterface +} + +type clusterRegistrationTokenClientCache struct { + client *clusterRegistrationTokenClient2 +} + +type clusterRegistrationTokenClient2 struct { + iface ClusterRegistrationTokenInterface + controller ClusterRegistrationTokenController +} + +func (n *clusterRegistrationTokenClient2) Interface() ClusterRegistrationTokenInterface { + return n.iface +} + +func (n *clusterRegistrationTokenClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterRegistrationTokenClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterRegistrationTokenClient2) Create(obj *ClusterRegistrationToken) (*ClusterRegistrationToken, error) { + return n.iface.Create(obj) +} + +func (n *clusterRegistrationTokenClient2) Get(namespace, name string, opts metav1.GetOptions) (*ClusterRegistrationToken, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterRegistrationTokenClient2) Update(obj *ClusterRegistrationToken) (*ClusterRegistrationToken, error) { + return n.iface.Update(obj) +} + +func (n *clusterRegistrationTokenClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterRegistrationTokenClient2) List(namespace string, opts metav1.ListOptions) (*ClusterRegistrationTokenList, error) { + return n.iface.List(opts) +} + +func (n *clusterRegistrationTokenClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterRegistrationTokenClientCache) Get(namespace, name string) (*ClusterRegistrationToken, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterRegistrationTokenClientCache) List(namespace string, selector labels.Selector) ([]*ClusterRegistrationToken, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterRegistrationTokenClient2) Cache() ClusterRegistrationTokenClientCache { + n.loadController() + return &clusterRegistrationTokenClientCache{ + client: n, + } +} + +func (n *clusterRegistrationTokenClient2) OnCreate(ctx context.Context, name string, sync ClusterRegistrationTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRegistrationTokenLifecycleDelegate{create: sync}) +} + +func (n *clusterRegistrationTokenClient2) OnChange(ctx context.Context, name string, sync ClusterRegistrationTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRegistrationTokenLifecycleDelegate{update: sync}) +} + +func (n *clusterRegistrationTokenClient2) OnRemove(ctx context.Context, name string, sync ClusterRegistrationTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRegistrationTokenLifecycleDelegate{remove: sync}) +} + +func (n *clusterRegistrationTokenClientCache) Index(name string, indexer ClusterRegistrationTokenIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ClusterRegistrationToken); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterRegistrationTokenClientCache) GetIndexed(name, key string) ([]*ClusterRegistrationToken, error) { + var result []*ClusterRegistrationToken + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ClusterRegistrationToken); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterRegistrationTokenClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterRegistrationTokenLifecycleDelegate struct { + create ClusterRegistrationTokenChangeHandlerFunc + update ClusterRegistrationTokenChangeHandlerFunc + remove ClusterRegistrationTokenChangeHandlerFunc +} + +func (n *clusterRegistrationTokenLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterRegistrationTokenLifecycleDelegate) Create(obj *ClusterRegistrationToken) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterRegistrationTokenLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterRegistrationTokenLifecycleDelegate) Remove(obj *ClusterRegistrationToken) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterRegistrationTokenLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterRegistrationTokenLifecycleDelegate) Updated(obj *ClusterRegistrationToken) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_controller.go index 3ab385b5..485fc1a1 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_controller.go @@ -37,6 +37,8 @@ type ClusterRoleTemplateBindingList struct { type ClusterRoleTemplateBindingHandlerFunc func(key string, obj *ClusterRoleTemplateBinding) (runtime.Object, error) +type ClusterRoleTemplateBindingChangeHandlerFunc func(obj *ClusterRoleTemplateBinding) (runtime.Object, error) + type ClusterRoleTemplateBindingLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterRoleTemplateBinding, err error) Get(namespace, name string) (*ClusterRoleTemplateBinding, error) @@ -248,3 +250,182 @@ func (s *clusterRoleTemplateBindingClient) AddClusterScopedLifecycle(ctx context sync := NewClusterRoleTemplateBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterRoleTemplateBindingIndexer func(obj *ClusterRoleTemplateBinding) ([]string, error) + +type ClusterRoleTemplateBindingClientCache interface { + Get(namespace, name string) (*ClusterRoleTemplateBinding, error) + List(namespace string, selector labels.Selector) ([]*ClusterRoleTemplateBinding, error) + + Index(name string, indexer ClusterRoleTemplateBindingIndexer) + GetIndexed(name, key string) ([]*ClusterRoleTemplateBinding, error) +} + +type ClusterRoleTemplateBindingClient interface { + Create(*ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error) + Get(namespace, name string, opts metav1.GetOptions) (*ClusterRoleTemplateBinding, error) + Update(*ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterRoleTemplateBindingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterRoleTemplateBindingClientCache + + OnCreate(ctx context.Context, name string, sync ClusterRoleTemplateBindingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterRoleTemplateBindingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterRoleTemplateBindingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterRoleTemplateBindingInterface +} + +type clusterRoleTemplateBindingClientCache struct { + client *clusterRoleTemplateBindingClient2 +} + +type clusterRoleTemplateBindingClient2 struct { + iface ClusterRoleTemplateBindingInterface + controller ClusterRoleTemplateBindingController +} + +func (n *clusterRoleTemplateBindingClient2) Interface() ClusterRoleTemplateBindingInterface { + return n.iface +} + +func (n *clusterRoleTemplateBindingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterRoleTemplateBindingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterRoleTemplateBindingClient2) Create(obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error) { + return n.iface.Create(obj) +} + +func (n *clusterRoleTemplateBindingClient2) Get(namespace, name string, opts metav1.GetOptions) (*ClusterRoleTemplateBinding, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterRoleTemplateBindingClient2) Update(obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error) { + return n.iface.Update(obj) +} + +func (n *clusterRoleTemplateBindingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterRoleTemplateBindingClient2) List(namespace string, opts metav1.ListOptions) (*ClusterRoleTemplateBindingList, error) { + return n.iface.List(opts) +} + +func (n *clusterRoleTemplateBindingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterRoleTemplateBindingClientCache) Get(namespace, name string) (*ClusterRoleTemplateBinding, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterRoleTemplateBindingClientCache) List(namespace string, selector labels.Selector) ([]*ClusterRoleTemplateBinding, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterRoleTemplateBindingClient2) Cache() ClusterRoleTemplateBindingClientCache { + n.loadController() + return &clusterRoleTemplateBindingClientCache{ + client: n, + } +} + +func (n *clusterRoleTemplateBindingClient2) OnCreate(ctx context.Context, name string, sync ClusterRoleTemplateBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleTemplateBindingLifecycleDelegate{create: sync}) +} + +func (n *clusterRoleTemplateBindingClient2) OnChange(ctx context.Context, name string, sync ClusterRoleTemplateBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleTemplateBindingLifecycleDelegate{update: sync}) +} + +func (n *clusterRoleTemplateBindingClient2) OnRemove(ctx context.Context, name string, sync ClusterRoleTemplateBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleTemplateBindingLifecycleDelegate{remove: sync}) +} + +func (n *clusterRoleTemplateBindingClientCache) Index(name string, indexer ClusterRoleTemplateBindingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ClusterRoleTemplateBinding); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterRoleTemplateBindingClientCache) GetIndexed(name, key string) ([]*ClusterRoleTemplateBinding, error) { + var result []*ClusterRoleTemplateBinding + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ClusterRoleTemplateBinding); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterRoleTemplateBindingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterRoleTemplateBindingLifecycleDelegate struct { + create ClusterRoleTemplateBindingChangeHandlerFunc + update ClusterRoleTemplateBindingChangeHandlerFunc + remove ClusterRoleTemplateBindingChangeHandlerFunc +} + +func (n *clusterRoleTemplateBindingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterRoleTemplateBindingLifecycleDelegate) Create(obj *ClusterRoleTemplateBinding) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterRoleTemplateBindingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterRoleTemplateBindingLifecycleDelegate) Remove(obj *ClusterRoleTemplateBinding) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterRoleTemplateBindingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterRoleTemplateBindingLifecycleDelegate) Updated(obj *ClusterRoleTemplateBinding) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go b/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go index 08c036a4..f1079597 100644 --- a/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go @@ -36,6 +36,8 @@ type ComposeConfigList struct { type ComposeConfigHandlerFunc func(key string, obj *ComposeConfig) (runtime.Object, error) +type ComposeConfigChangeHandlerFunc func(obj *ComposeConfig) (runtime.Object, error) + type ComposeConfigLister interface { List(namespace string, selector labels.Selector) (ret []*ComposeConfig, err error) Get(namespace, name string) (*ComposeConfig, error) @@ -247,3 +249,182 @@ func (s *composeConfigClient) AddClusterScopedLifecycle(ctx context.Context, nam sync := NewComposeConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ComposeConfigIndexer func(obj *ComposeConfig) ([]string, error) + +type ComposeConfigClientCache interface { + Get(namespace, name string) (*ComposeConfig, error) + List(namespace string, selector labels.Selector) ([]*ComposeConfig, error) + + Index(name string, indexer ComposeConfigIndexer) + GetIndexed(name, key string) ([]*ComposeConfig, error) +} + +type ComposeConfigClient interface { + Create(*ComposeConfig) (*ComposeConfig, error) + Get(namespace, name string, opts metav1.GetOptions) (*ComposeConfig, error) + Update(*ComposeConfig) (*ComposeConfig, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ComposeConfigList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ComposeConfigClientCache + + OnCreate(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ComposeConfigInterface +} + +type composeConfigClientCache struct { + client *composeConfigClient2 +} + +type composeConfigClient2 struct { + iface ComposeConfigInterface + controller ComposeConfigController +} + +func (n *composeConfigClient2) Interface() ComposeConfigInterface { + return n.iface +} + +func (n *composeConfigClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *composeConfigClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *composeConfigClient2) Create(obj *ComposeConfig) (*ComposeConfig, error) { + return n.iface.Create(obj) +} + +func (n *composeConfigClient2) Get(namespace, name string, opts metav1.GetOptions) (*ComposeConfig, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *composeConfigClient2) Update(obj *ComposeConfig) (*ComposeConfig, error) { + return n.iface.Update(obj) +} + +func (n *composeConfigClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *composeConfigClient2) List(namespace string, opts metav1.ListOptions) (*ComposeConfigList, error) { + return n.iface.List(opts) +} + +func (n *composeConfigClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *composeConfigClientCache) Get(namespace, name string) (*ComposeConfig, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *composeConfigClientCache) List(namespace string, selector labels.Selector) ([]*ComposeConfig, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *composeConfigClient2) Cache() ComposeConfigClientCache { + n.loadController() + return &composeConfigClientCache{ + client: n, + } +} + +func (n *composeConfigClient2) OnCreate(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &composeConfigLifecycleDelegate{create: sync}) +} + +func (n *composeConfigClient2) OnChange(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &composeConfigLifecycleDelegate{update: sync}) +} + +func (n *composeConfigClient2) OnRemove(ctx context.Context, name string, sync ComposeConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &composeConfigLifecycleDelegate{remove: sync}) +} + +func (n *composeConfigClientCache) Index(name string, indexer ComposeConfigIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ComposeConfig); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *composeConfigClientCache) GetIndexed(name, key string) ([]*ComposeConfig, error) { + var result []*ComposeConfig + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ComposeConfig); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *composeConfigClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type composeConfigLifecycleDelegate struct { + create ComposeConfigChangeHandlerFunc + update ComposeConfigChangeHandlerFunc + remove ComposeConfigChangeHandlerFunc +} + +func (n *composeConfigLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *composeConfigLifecycleDelegate) Create(obj *ComposeConfig) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *composeConfigLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *composeConfigLifecycleDelegate) Remove(obj *ComposeConfig) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *composeConfigLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *composeConfigLifecycleDelegate) Updated(obj *ComposeConfig) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_dynamic_schema_controller.go b/apis/management.cattle.io/v3/zz_generated_dynamic_schema_controller.go index 78ca0817..c9be4705 100644 --- a/apis/management.cattle.io/v3/zz_generated_dynamic_schema_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_dynamic_schema_controller.go @@ -36,6 +36,8 @@ type DynamicSchemaList struct { type DynamicSchemaHandlerFunc func(key string, obj *DynamicSchema) (runtime.Object, error) +type DynamicSchemaChangeHandlerFunc func(obj *DynamicSchema) (runtime.Object, error) + type DynamicSchemaLister interface { List(namespace string, selector labels.Selector) (ret []*DynamicSchema, err error) Get(namespace, name string) (*DynamicSchema, error) @@ -247,3 +249,182 @@ func (s *dynamicSchemaClient) AddClusterScopedLifecycle(ctx context.Context, nam sync := NewDynamicSchemaLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type DynamicSchemaIndexer func(obj *DynamicSchema) ([]string, error) + +type DynamicSchemaClientCache interface { + Get(namespace, name string) (*DynamicSchema, error) + List(namespace string, selector labels.Selector) ([]*DynamicSchema, error) + + Index(name string, indexer DynamicSchemaIndexer) + GetIndexed(name, key string) ([]*DynamicSchema, error) +} + +type DynamicSchemaClient interface { + Create(*DynamicSchema) (*DynamicSchema, error) + Get(namespace, name string, opts metav1.GetOptions) (*DynamicSchema, error) + Update(*DynamicSchema) (*DynamicSchema, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*DynamicSchemaList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() DynamicSchemaClientCache + + OnCreate(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() DynamicSchemaInterface +} + +type dynamicSchemaClientCache struct { + client *dynamicSchemaClient2 +} + +type dynamicSchemaClient2 struct { + iface DynamicSchemaInterface + controller DynamicSchemaController +} + +func (n *dynamicSchemaClient2) Interface() DynamicSchemaInterface { + return n.iface +} + +func (n *dynamicSchemaClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *dynamicSchemaClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *dynamicSchemaClient2) Create(obj *DynamicSchema) (*DynamicSchema, error) { + return n.iface.Create(obj) +} + +func (n *dynamicSchemaClient2) Get(namespace, name string, opts metav1.GetOptions) (*DynamicSchema, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *dynamicSchemaClient2) Update(obj *DynamicSchema) (*DynamicSchema, error) { + return n.iface.Update(obj) +} + +func (n *dynamicSchemaClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *dynamicSchemaClient2) List(namespace string, opts metav1.ListOptions) (*DynamicSchemaList, error) { + return n.iface.List(opts) +} + +func (n *dynamicSchemaClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *dynamicSchemaClientCache) Get(namespace, name string) (*DynamicSchema, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *dynamicSchemaClientCache) List(namespace string, selector labels.Selector) ([]*DynamicSchema, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *dynamicSchemaClient2) Cache() DynamicSchemaClientCache { + n.loadController() + return &dynamicSchemaClientCache{ + client: n, + } +} + +func (n *dynamicSchemaClient2) OnCreate(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &dynamicSchemaLifecycleDelegate{create: sync}) +} + +func (n *dynamicSchemaClient2) OnChange(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &dynamicSchemaLifecycleDelegate{update: sync}) +} + +func (n *dynamicSchemaClient2) OnRemove(ctx context.Context, name string, sync DynamicSchemaChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &dynamicSchemaLifecycleDelegate{remove: sync}) +} + +func (n *dynamicSchemaClientCache) Index(name string, indexer DynamicSchemaIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*DynamicSchema); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *dynamicSchemaClientCache) GetIndexed(name, key string) ([]*DynamicSchema, error) { + var result []*DynamicSchema + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*DynamicSchema); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *dynamicSchemaClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type dynamicSchemaLifecycleDelegate struct { + create DynamicSchemaChangeHandlerFunc + update DynamicSchemaChangeHandlerFunc + remove DynamicSchemaChangeHandlerFunc +} + +func (n *dynamicSchemaLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *dynamicSchemaLifecycleDelegate) Create(obj *DynamicSchema) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *dynamicSchemaLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *dynamicSchemaLifecycleDelegate) Remove(obj *DynamicSchema) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *dynamicSchemaLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *dynamicSchemaLifecycleDelegate) Updated(obj *DynamicSchema) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_global_role_binding_controller.go b/apis/management.cattle.io/v3/zz_generated_global_role_binding_controller.go index 97e28cec..4566e80b 100644 --- a/apis/management.cattle.io/v3/zz_generated_global_role_binding_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_global_role_binding_controller.go @@ -36,6 +36,8 @@ type GlobalRoleBindingList struct { type GlobalRoleBindingHandlerFunc func(key string, obj *GlobalRoleBinding) (runtime.Object, error) +type GlobalRoleBindingChangeHandlerFunc func(obj *GlobalRoleBinding) (runtime.Object, error) + type GlobalRoleBindingLister interface { List(namespace string, selector labels.Selector) (ret []*GlobalRoleBinding, err error) Get(namespace, name string) (*GlobalRoleBinding, error) @@ -247,3 +249,182 @@ func (s *globalRoleBindingClient) AddClusterScopedLifecycle(ctx context.Context, sync := NewGlobalRoleBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type GlobalRoleBindingIndexer func(obj *GlobalRoleBinding) ([]string, error) + +type GlobalRoleBindingClientCache interface { + Get(namespace, name string) (*GlobalRoleBinding, error) + List(namespace string, selector labels.Selector) ([]*GlobalRoleBinding, error) + + Index(name string, indexer GlobalRoleBindingIndexer) + GetIndexed(name, key string) ([]*GlobalRoleBinding, error) +} + +type GlobalRoleBindingClient interface { + Create(*GlobalRoleBinding) (*GlobalRoleBinding, error) + Get(namespace, name string, opts metav1.GetOptions) (*GlobalRoleBinding, error) + Update(*GlobalRoleBinding) (*GlobalRoleBinding, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*GlobalRoleBindingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() GlobalRoleBindingClientCache + + OnCreate(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() GlobalRoleBindingInterface +} + +type globalRoleBindingClientCache struct { + client *globalRoleBindingClient2 +} + +type globalRoleBindingClient2 struct { + iface GlobalRoleBindingInterface + controller GlobalRoleBindingController +} + +func (n *globalRoleBindingClient2) Interface() GlobalRoleBindingInterface { + return n.iface +} + +func (n *globalRoleBindingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *globalRoleBindingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *globalRoleBindingClient2) Create(obj *GlobalRoleBinding) (*GlobalRoleBinding, error) { + return n.iface.Create(obj) +} + +func (n *globalRoleBindingClient2) Get(namespace, name string, opts metav1.GetOptions) (*GlobalRoleBinding, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *globalRoleBindingClient2) Update(obj *GlobalRoleBinding) (*GlobalRoleBinding, error) { + return n.iface.Update(obj) +} + +func (n *globalRoleBindingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *globalRoleBindingClient2) List(namespace string, opts metav1.ListOptions) (*GlobalRoleBindingList, error) { + return n.iface.List(opts) +} + +func (n *globalRoleBindingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *globalRoleBindingClientCache) Get(namespace, name string) (*GlobalRoleBinding, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *globalRoleBindingClientCache) List(namespace string, selector labels.Selector) ([]*GlobalRoleBinding, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *globalRoleBindingClient2) Cache() GlobalRoleBindingClientCache { + n.loadController() + return &globalRoleBindingClientCache{ + client: n, + } +} + +func (n *globalRoleBindingClient2) OnCreate(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &globalRoleBindingLifecycleDelegate{create: sync}) +} + +func (n *globalRoleBindingClient2) OnChange(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &globalRoleBindingLifecycleDelegate{update: sync}) +} + +func (n *globalRoleBindingClient2) OnRemove(ctx context.Context, name string, sync GlobalRoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &globalRoleBindingLifecycleDelegate{remove: sync}) +} + +func (n *globalRoleBindingClientCache) Index(name string, indexer GlobalRoleBindingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*GlobalRoleBinding); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *globalRoleBindingClientCache) GetIndexed(name, key string) ([]*GlobalRoleBinding, error) { + var result []*GlobalRoleBinding + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*GlobalRoleBinding); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *globalRoleBindingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type globalRoleBindingLifecycleDelegate struct { + create GlobalRoleBindingChangeHandlerFunc + update GlobalRoleBindingChangeHandlerFunc + remove GlobalRoleBindingChangeHandlerFunc +} + +func (n *globalRoleBindingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *globalRoleBindingLifecycleDelegate) Create(obj *GlobalRoleBinding) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *globalRoleBindingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *globalRoleBindingLifecycleDelegate) Remove(obj *GlobalRoleBinding) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *globalRoleBindingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *globalRoleBindingLifecycleDelegate) Updated(obj *GlobalRoleBinding) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_global_role_controller.go b/apis/management.cattle.io/v3/zz_generated_global_role_controller.go index ec537dfb..8f2d52ee 100644 --- a/apis/management.cattle.io/v3/zz_generated_global_role_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_global_role_controller.go @@ -36,6 +36,8 @@ type GlobalRoleList struct { type GlobalRoleHandlerFunc func(key string, obj *GlobalRole) (runtime.Object, error) +type GlobalRoleChangeHandlerFunc func(obj *GlobalRole) (runtime.Object, error) + type GlobalRoleLister interface { List(namespace string, selector labels.Selector) (ret []*GlobalRole, err error) Get(namespace, name string) (*GlobalRole, error) @@ -247,3 +249,182 @@ func (s *globalRoleClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewGlobalRoleLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type GlobalRoleIndexer func(obj *GlobalRole) ([]string, error) + +type GlobalRoleClientCache interface { + Get(namespace, name string) (*GlobalRole, error) + List(namespace string, selector labels.Selector) ([]*GlobalRole, error) + + Index(name string, indexer GlobalRoleIndexer) + GetIndexed(name, key string) ([]*GlobalRole, error) +} + +type GlobalRoleClient interface { + Create(*GlobalRole) (*GlobalRole, error) + Get(namespace, name string, opts metav1.GetOptions) (*GlobalRole, error) + Update(*GlobalRole) (*GlobalRole, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*GlobalRoleList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() GlobalRoleClientCache + + OnCreate(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() GlobalRoleInterface +} + +type globalRoleClientCache struct { + client *globalRoleClient2 +} + +type globalRoleClient2 struct { + iface GlobalRoleInterface + controller GlobalRoleController +} + +func (n *globalRoleClient2) Interface() GlobalRoleInterface { + return n.iface +} + +func (n *globalRoleClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *globalRoleClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *globalRoleClient2) Create(obj *GlobalRole) (*GlobalRole, error) { + return n.iface.Create(obj) +} + +func (n *globalRoleClient2) Get(namespace, name string, opts metav1.GetOptions) (*GlobalRole, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *globalRoleClient2) Update(obj *GlobalRole) (*GlobalRole, error) { + return n.iface.Update(obj) +} + +func (n *globalRoleClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *globalRoleClient2) List(namespace string, opts metav1.ListOptions) (*GlobalRoleList, error) { + return n.iface.List(opts) +} + +func (n *globalRoleClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *globalRoleClientCache) Get(namespace, name string) (*GlobalRole, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *globalRoleClientCache) List(namespace string, selector labels.Selector) ([]*GlobalRole, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *globalRoleClient2) Cache() GlobalRoleClientCache { + n.loadController() + return &globalRoleClientCache{ + client: n, + } +} + +func (n *globalRoleClient2) OnCreate(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &globalRoleLifecycleDelegate{create: sync}) +} + +func (n *globalRoleClient2) OnChange(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &globalRoleLifecycleDelegate{update: sync}) +} + +func (n *globalRoleClient2) OnRemove(ctx context.Context, name string, sync GlobalRoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &globalRoleLifecycleDelegate{remove: sync}) +} + +func (n *globalRoleClientCache) Index(name string, indexer GlobalRoleIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*GlobalRole); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *globalRoleClientCache) GetIndexed(name, key string) ([]*GlobalRole, error) { + var result []*GlobalRole + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*GlobalRole); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *globalRoleClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type globalRoleLifecycleDelegate struct { + create GlobalRoleChangeHandlerFunc + update GlobalRoleChangeHandlerFunc + remove GlobalRoleChangeHandlerFunc +} + +func (n *globalRoleLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *globalRoleLifecycleDelegate) Create(obj *GlobalRole) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *globalRoleLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *globalRoleLifecycleDelegate) Remove(obj *GlobalRole) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *globalRoleLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *globalRoleLifecycleDelegate) Updated(obj *GlobalRole) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_group_controller.go b/apis/management.cattle.io/v3/zz_generated_group_controller.go index 4e725aeb..71f3723d 100644 --- a/apis/management.cattle.io/v3/zz_generated_group_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_group_controller.go @@ -36,6 +36,8 @@ type GroupList struct { type GroupHandlerFunc func(key string, obj *Group) (runtime.Object, error) +type GroupChangeHandlerFunc func(obj *Group) (runtime.Object, error) + type GroupLister interface { List(namespace string, selector labels.Selector) (ret []*Group, err error) Get(namespace, name string) (*Group, error) @@ -247,3 +249,182 @@ func (s *groupClient) AddClusterScopedLifecycle(ctx context.Context, name, clust sync := NewGroupLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type GroupIndexer func(obj *Group) ([]string, error) + +type GroupClientCache interface { + Get(namespace, name string) (*Group, error) + List(namespace string, selector labels.Selector) ([]*Group, error) + + Index(name string, indexer GroupIndexer) + GetIndexed(name, key string) ([]*Group, error) +} + +type GroupClient interface { + Create(*Group) (*Group, error) + Get(namespace, name string, opts metav1.GetOptions) (*Group, error) + Update(*Group) (*Group, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*GroupList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() GroupClientCache + + OnCreate(ctx context.Context, name string, sync GroupChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync GroupChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync GroupChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() GroupInterface +} + +type groupClientCache struct { + client *groupClient2 +} + +type groupClient2 struct { + iface GroupInterface + controller GroupController +} + +func (n *groupClient2) Interface() GroupInterface { + return n.iface +} + +func (n *groupClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *groupClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *groupClient2) Create(obj *Group) (*Group, error) { + return n.iface.Create(obj) +} + +func (n *groupClient2) Get(namespace, name string, opts metav1.GetOptions) (*Group, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *groupClient2) Update(obj *Group) (*Group, error) { + return n.iface.Update(obj) +} + +func (n *groupClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *groupClient2) List(namespace string, opts metav1.ListOptions) (*GroupList, error) { + return n.iface.List(opts) +} + +func (n *groupClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *groupClientCache) Get(namespace, name string) (*Group, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *groupClientCache) List(namespace string, selector labels.Selector) ([]*Group, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *groupClient2) Cache() GroupClientCache { + n.loadController() + return &groupClientCache{ + client: n, + } +} + +func (n *groupClient2) OnCreate(ctx context.Context, name string, sync GroupChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &groupLifecycleDelegate{create: sync}) +} + +func (n *groupClient2) OnChange(ctx context.Context, name string, sync GroupChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &groupLifecycleDelegate{update: sync}) +} + +func (n *groupClient2) OnRemove(ctx context.Context, name string, sync GroupChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &groupLifecycleDelegate{remove: sync}) +} + +func (n *groupClientCache) Index(name string, indexer GroupIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Group); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *groupClientCache) GetIndexed(name, key string) ([]*Group, error) { + var result []*Group + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Group); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *groupClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type groupLifecycleDelegate struct { + create GroupChangeHandlerFunc + update GroupChangeHandlerFunc + remove GroupChangeHandlerFunc +} + +func (n *groupLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *groupLifecycleDelegate) Create(obj *Group) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *groupLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *groupLifecycleDelegate) Remove(obj *Group) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *groupLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *groupLifecycleDelegate) Updated(obj *Group) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_group_member_controller.go b/apis/management.cattle.io/v3/zz_generated_group_member_controller.go index efad6c11..e43bd8c3 100644 --- a/apis/management.cattle.io/v3/zz_generated_group_member_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_group_member_controller.go @@ -36,6 +36,8 @@ type GroupMemberList struct { type GroupMemberHandlerFunc func(key string, obj *GroupMember) (runtime.Object, error) +type GroupMemberChangeHandlerFunc func(obj *GroupMember) (runtime.Object, error) + type GroupMemberLister interface { List(namespace string, selector labels.Selector) (ret []*GroupMember, err error) Get(namespace, name string) (*GroupMember, error) @@ -247,3 +249,182 @@ func (s *groupMemberClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewGroupMemberLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type GroupMemberIndexer func(obj *GroupMember) ([]string, error) + +type GroupMemberClientCache interface { + Get(namespace, name string) (*GroupMember, error) + List(namespace string, selector labels.Selector) ([]*GroupMember, error) + + Index(name string, indexer GroupMemberIndexer) + GetIndexed(name, key string) ([]*GroupMember, error) +} + +type GroupMemberClient interface { + Create(*GroupMember) (*GroupMember, error) + Get(namespace, name string, opts metav1.GetOptions) (*GroupMember, error) + Update(*GroupMember) (*GroupMember, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*GroupMemberList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() GroupMemberClientCache + + OnCreate(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() GroupMemberInterface +} + +type groupMemberClientCache struct { + client *groupMemberClient2 +} + +type groupMemberClient2 struct { + iface GroupMemberInterface + controller GroupMemberController +} + +func (n *groupMemberClient2) Interface() GroupMemberInterface { + return n.iface +} + +func (n *groupMemberClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *groupMemberClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *groupMemberClient2) Create(obj *GroupMember) (*GroupMember, error) { + return n.iface.Create(obj) +} + +func (n *groupMemberClient2) Get(namespace, name string, opts metav1.GetOptions) (*GroupMember, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *groupMemberClient2) Update(obj *GroupMember) (*GroupMember, error) { + return n.iface.Update(obj) +} + +func (n *groupMemberClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *groupMemberClient2) List(namespace string, opts metav1.ListOptions) (*GroupMemberList, error) { + return n.iface.List(opts) +} + +func (n *groupMemberClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *groupMemberClientCache) Get(namespace, name string) (*GroupMember, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *groupMemberClientCache) List(namespace string, selector labels.Selector) ([]*GroupMember, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *groupMemberClient2) Cache() GroupMemberClientCache { + n.loadController() + return &groupMemberClientCache{ + client: n, + } +} + +func (n *groupMemberClient2) OnCreate(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &groupMemberLifecycleDelegate{create: sync}) +} + +func (n *groupMemberClient2) OnChange(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &groupMemberLifecycleDelegate{update: sync}) +} + +func (n *groupMemberClient2) OnRemove(ctx context.Context, name string, sync GroupMemberChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &groupMemberLifecycleDelegate{remove: sync}) +} + +func (n *groupMemberClientCache) Index(name string, indexer GroupMemberIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*GroupMember); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *groupMemberClientCache) GetIndexed(name, key string) ([]*GroupMember, error) { + var result []*GroupMember + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*GroupMember); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *groupMemberClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type groupMemberLifecycleDelegate struct { + create GroupMemberChangeHandlerFunc + update GroupMemberChangeHandlerFunc + remove GroupMemberChangeHandlerFunc +} + +func (n *groupMemberLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *groupMemberLifecycleDelegate) Create(obj *GroupMember) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *groupMemberLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *groupMemberLifecycleDelegate) Remove(obj *GroupMember) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *groupMemberLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *groupMemberLifecycleDelegate) Updated(obj *GroupMember) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} 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 952a7b07..cba0b4be 100644 --- a/apis/management.cattle.io/v3/zz_generated_k8s_client.go +++ b/apis/management.cattle.io/v3/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -58,6 +61,48 @@ type Interface interface { ClusterCatalogsGetter } +type Clients struct { + NodePool NodePoolClient + Node NodeClient + NodeDriver NodeDriverClient + NodeTemplate NodeTemplateClient + Project ProjectClient + GlobalRole GlobalRoleClient + GlobalRoleBinding GlobalRoleBindingClient + RoleTemplate RoleTemplateClient + PodSecurityPolicyTemplate PodSecurityPolicyTemplateClient + PodSecurityPolicyTemplateProjectBinding PodSecurityPolicyTemplateProjectBindingClient + ClusterRoleTemplateBinding ClusterRoleTemplateBindingClient + ProjectRoleTemplateBinding ProjectRoleTemplateBindingClient + Cluster ClusterClient + ClusterRegistrationToken ClusterRegistrationTokenClient + Catalog CatalogClient + Template TemplateClient + TemplateVersion TemplateVersionClient + TemplateContent TemplateContentClient + Group GroupClient + GroupMember GroupMemberClient + Principal PrincipalClient + User UserClient + AuthConfig AuthConfigClient + LdapConfig LdapConfigClient + Token TokenClient + DynamicSchema DynamicSchemaClient + Preference PreferenceClient + UserAttribute UserAttributeClient + ProjectNetworkPolicy ProjectNetworkPolicyClient + ClusterLogging ClusterLoggingClient + ProjectLogging ProjectLoggingClient + ListenConfig ListenConfigClient + Setting SettingClient + Notifier NotifierClient + ClusterAlert ClusterAlertClient + ProjectAlert ProjectAlertClient + ComposeConfig ComposeConfigClient + ProjectCatalog ProjectCatalogClient + ClusterCatalog ClusterCatalogClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -110,13 +155,152 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + NodePool: &nodePoolClient2{ + iface: iface.NodePools(""), + }, + Node: &nodeClient2{ + iface: iface.Nodes(""), + }, + NodeDriver: &nodeDriverClient2{ + iface: iface.NodeDrivers(""), + }, + NodeTemplate: &nodeTemplateClient2{ + iface: iface.NodeTemplates(""), + }, + Project: &projectClient2{ + iface: iface.Projects(""), + }, + GlobalRole: &globalRoleClient2{ + iface: iface.GlobalRoles(""), + }, + GlobalRoleBinding: &globalRoleBindingClient2{ + iface: iface.GlobalRoleBindings(""), + }, + RoleTemplate: &roleTemplateClient2{ + iface: iface.RoleTemplates(""), + }, + PodSecurityPolicyTemplate: &podSecurityPolicyTemplateClient2{ + iface: iface.PodSecurityPolicyTemplates(""), + }, + PodSecurityPolicyTemplateProjectBinding: &podSecurityPolicyTemplateProjectBindingClient2{ + iface: iface.PodSecurityPolicyTemplateProjectBindings(""), + }, + ClusterRoleTemplateBinding: &clusterRoleTemplateBindingClient2{ + iface: iface.ClusterRoleTemplateBindings(""), + }, + ProjectRoleTemplateBinding: &projectRoleTemplateBindingClient2{ + iface: iface.ProjectRoleTemplateBindings(""), + }, + Cluster: &clusterClient2{ + iface: iface.Clusters(""), + }, + ClusterRegistrationToken: &clusterRegistrationTokenClient2{ + iface: iface.ClusterRegistrationTokens(""), + }, + Catalog: &catalogClient2{ + iface: iface.Catalogs(""), + }, + Template: &templateClient2{ + iface: iface.Templates(""), + }, + TemplateVersion: &templateVersionClient2{ + iface: iface.TemplateVersions(""), + }, + TemplateContent: &templateContentClient2{ + iface: iface.TemplateContents(""), + }, + Group: &groupClient2{ + iface: iface.Groups(""), + }, + GroupMember: &groupMemberClient2{ + iface: iface.GroupMembers(""), + }, + Principal: &principalClient2{ + iface: iface.Principals(""), + }, + User: &userClient2{ + iface: iface.Users(""), + }, + AuthConfig: &authConfigClient2{ + iface: iface.AuthConfigs(""), + }, + LdapConfig: &ldapConfigClient2{ + iface: iface.LdapConfigs(""), + }, + Token: &tokenClient2{ + iface: iface.Tokens(""), + }, + DynamicSchema: &dynamicSchemaClient2{ + iface: iface.DynamicSchemas(""), + }, + Preference: &preferenceClient2{ + iface: iface.Preferences(""), + }, + UserAttribute: &userAttributeClient2{ + iface: iface.UserAttributes(""), + }, + ProjectNetworkPolicy: &projectNetworkPolicyClient2{ + iface: iface.ProjectNetworkPolicies(""), + }, + ClusterLogging: &clusterLoggingClient2{ + iface: iface.ClusterLoggings(""), + }, + ProjectLogging: &projectLoggingClient2{ + iface: iface.ProjectLoggings(""), + }, + ListenConfig: &listenConfigClient2{ + iface: iface.ListenConfigs(""), + }, + Setting: &settingClient2{ + iface: iface.Settings(""), + }, + Notifier: ¬ifierClient2{ + iface: iface.Notifiers(""), + }, + ClusterAlert: &clusterAlertClient2{ + iface: iface.ClusterAlerts(""), + }, + ProjectAlert: &projectAlertClient2{ + iface: iface.ProjectAlerts(""), + }, + ComposeConfig: &composeConfigClient2{ + iface: iface.ComposeConfigs(""), + }, + ProjectCatalog: &projectCatalogClient2{ + iface: iface.ProjectCatalogs(""), + }, + ClusterCatalog: &clusterCatalogClient2{ + iface: iface.ClusterCatalogs(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/management.cattle.io/v3/zz_generated_ldap_config_controller.go b/apis/management.cattle.io/v3/zz_generated_ldap_config_controller.go index 398a19a6..003bd4a5 100644 --- a/apis/management.cattle.io/v3/zz_generated_ldap_config_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_ldap_config_controller.go @@ -36,6 +36,8 @@ type LdapConfigList struct { type LdapConfigHandlerFunc func(key string, obj *LdapConfig) (runtime.Object, error) +type LdapConfigChangeHandlerFunc func(obj *LdapConfig) (runtime.Object, error) + type LdapConfigLister interface { List(namespace string, selector labels.Selector) (ret []*LdapConfig, err error) Get(namespace, name string) (*LdapConfig, error) @@ -247,3 +249,182 @@ func (s *ldapConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewLdapConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type LdapConfigIndexer func(obj *LdapConfig) ([]string, error) + +type LdapConfigClientCache interface { + Get(namespace, name string) (*LdapConfig, error) + List(namespace string, selector labels.Selector) ([]*LdapConfig, error) + + Index(name string, indexer LdapConfigIndexer) + GetIndexed(name, key string) ([]*LdapConfig, error) +} + +type LdapConfigClient interface { + Create(*LdapConfig) (*LdapConfig, error) + Get(namespace, name string, opts metav1.GetOptions) (*LdapConfig, error) + Update(*LdapConfig) (*LdapConfig, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*LdapConfigList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() LdapConfigClientCache + + OnCreate(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() LdapConfigInterface +} + +type ldapConfigClientCache struct { + client *ldapConfigClient2 +} + +type ldapConfigClient2 struct { + iface LdapConfigInterface + controller LdapConfigController +} + +func (n *ldapConfigClient2) Interface() LdapConfigInterface { + return n.iface +} + +func (n *ldapConfigClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *ldapConfigClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *ldapConfigClient2) Create(obj *LdapConfig) (*LdapConfig, error) { + return n.iface.Create(obj) +} + +func (n *ldapConfigClient2) Get(namespace, name string, opts metav1.GetOptions) (*LdapConfig, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *ldapConfigClient2) Update(obj *LdapConfig) (*LdapConfig, error) { + return n.iface.Update(obj) +} + +func (n *ldapConfigClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *ldapConfigClient2) List(namespace string, opts metav1.ListOptions) (*LdapConfigList, error) { + return n.iface.List(opts) +} + +func (n *ldapConfigClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *ldapConfigClientCache) Get(namespace, name string) (*LdapConfig, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *ldapConfigClientCache) List(namespace string, selector labels.Selector) ([]*LdapConfig, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *ldapConfigClient2) Cache() LdapConfigClientCache { + n.loadController() + return &ldapConfigClientCache{ + client: n, + } +} + +func (n *ldapConfigClient2) OnCreate(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &ldapConfigLifecycleDelegate{create: sync}) +} + +func (n *ldapConfigClient2) OnChange(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &ldapConfigLifecycleDelegate{update: sync}) +} + +func (n *ldapConfigClient2) OnRemove(ctx context.Context, name string, sync LdapConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &ldapConfigLifecycleDelegate{remove: sync}) +} + +func (n *ldapConfigClientCache) Index(name string, indexer LdapConfigIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*LdapConfig); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *ldapConfigClientCache) GetIndexed(name, key string) ([]*LdapConfig, error) { + var result []*LdapConfig + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*LdapConfig); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *ldapConfigClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type ldapConfigLifecycleDelegate struct { + create LdapConfigChangeHandlerFunc + update LdapConfigChangeHandlerFunc + remove LdapConfigChangeHandlerFunc +} + +func (n *ldapConfigLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *ldapConfigLifecycleDelegate) Create(obj *LdapConfig) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *ldapConfigLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *ldapConfigLifecycleDelegate) Remove(obj *LdapConfig) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *ldapConfigLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *ldapConfigLifecycleDelegate) Updated(obj *LdapConfig) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_listen_config_controller.go b/apis/management.cattle.io/v3/zz_generated_listen_config_controller.go index ab4e6d7d..b729ddb8 100644 --- a/apis/management.cattle.io/v3/zz_generated_listen_config_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_listen_config_controller.go @@ -36,6 +36,8 @@ type ListenConfigList struct { type ListenConfigHandlerFunc func(key string, obj *ListenConfig) (runtime.Object, error) +type ListenConfigChangeHandlerFunc func(obj *ListenConfig) (runtime.Object, error) + type ListenConfigLister interface { List(namespace string, selector labels.Selector) (ret []*ListenConfig, err error) Get(namespace, name string) (*ListenConfig, error) @@ -247,3 +249,182 @@ func (s *listenConfigClient) AddClusterScopedLifecycle(ctx context.Context, name sync := NewListenConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ListenConfigIndexer func(obj *ListenConfig) ([]string, error) + +type ListenConfigClientCache interface { + Get(namespace, name string) (*ListenConfig, error) + List(namespace string, selector labels.Selector) ([]*ListenConfig, error) + + Index(name string, indexer ListenConfigIndexer) + GetIndexed(name, key string) ([]*ListenConfig, error) +} + +type ListenConfigClient interface { + Create(*ListenConfig) (*ListenConfig, error) + Get(namespace, name string, opts metav1.GetOptions) (*ListenConfig, error) + Update(*ListenConfig) (*ListenConfig, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ListenConfigList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ListenConfigClientCache + + OnCreate(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ListenConfigInterface +} + +type listenConfigClientCache struct { + client *listenConfigClient2 +} + +type listenConfigClient2 struct { + iface ListenConfigInterface + controller ListenConfigController +} + +func (n *listenConfigClient2) Interface() ListenConfigInterface { + return n.iface +} + +func (n *listenConfigClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *listenConfigClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *listenConfigClient2) Create(obj *ListenConfig) (*ListenConfig, error) { + return n.iface.Create(obj) +} + +func (n *listenConfigClient2) Get(namespace, name string, opts metav1.GetOptions) (*ListenConfig, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *listenConfigClient2) Update(obj *ListenConfig) (*ListenConfig, error) { + return n.iface.Update(obj) +} + +func (n *listenConfigClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *listenConfigClient2) List(namespace string, opts metav1.ListOptions) (*ListenConfigList, error) { + return n.iface.List(opts) +} + +func (n *listenConfigClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *listenConfigClientCache) Get(namespace, name string) (*ListenConfig, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *listenConfigClientCache) List(namespace string, selector labels.Selector) ([]*ListenConfig, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *listenConfigClient2) Cache() ListenConfigClientCache { + n.loadController() + return &listenConfigClientCache{ + client: n, + } +} + +func (n *listenConfigClient2) OnCreate(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &listenConfigLifecycleDelegate{create: sync}) +} + +func (n *listenConfigClient2) OnChange(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &listenConfigLifecycleDelegate{update: sync}) +} + +func (n *listenConfigClient2) OnRemove(ctx context.Context, name string, sync ListenConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &listenConfigLifecycleDelegate{remove: sync}) +} + +func (n *listenConfigClientCache) Index(name string, indexer ListenConfigIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ListenConfig); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *listenConfigClientCache) GetIndexed(name, key string) ([]*ListenConfig, error) { + var result []*ListenConfig + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ListenConfig); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *listenConfigClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type listenConfigLifecycleDelegate struct { + create ListenConfigChangeHandlerFunc + update ListenConfigChangeHandlerFunc + remove ListenConfigChangeHandlerFunc +} + +func (n *listenConfigLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *listenConfigLifecycleDelegate) Create(obj *ListenConfig) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *listenConfigLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *listenConfigLifecycleDelegate) Remove(obj *ListenConfig) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *listenConfigLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *listenConfigLifecycleDelegate) Updated(obj *ListenConfig) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_node_controller.go b/apis/management.cattle.io/v3/zz_generated_node_controller.go index 6654497a..bb2adf07 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_node_controller.go @@ -37,6 +37,8 @@ type NodeList struct { type NodeHandlerFunc func(key string, obj *Node) (runtime.Object, error) +type NodeChangeHandlerFunc func(obj *Node) (runtime.Object, error) + type NodeLister interface { List(namespace string, selector labels.Selector) (ret []*Node, err error) Get(namespace, name string) (*Node, error) @@ -248,3 +250,182 @@ func (s *nodeClient) AddClusterScopedLifecycle(ctx context.Context, name, cluste sync := NewNodeLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NodeIndexer func(obj *Node) ([]string, error) + +type NodeClientCache interface { + Get(namespace, name string) (*Node, error) + List(namespace string, selector labels.Selector) ([]*Node, error) + + Index(name string, indexer NodeIndexer) + GetIndexed(name, key string) ([]*Node, error) +} + +type NodeClient interface { + Create(*Node) (*Node, error) + Get(namespace, name string, opts metav1.GetOptions) (*Node, error) + Update(*Node) (*Node, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NodeList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NodeClientCache + + OnCreate(ctx context.Context, name string, sync NodeChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NodeChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NodeChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NodeInterface +} + +type nodeClientCache struct { + client *nodeClient2 +} + +type nodeClient2 struct { + iface NodeInterface + controller NodeController +} + +func (n *nodeClient2) Interface() NodeInterface { + return n.iface +} + +func (n *nodeClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *nodeClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *nodeClient2) Create(obj *Node) (*Node, error) { + return n.iface.Create(obj) +} + +func (n *nodeClient2) Get(namespace, name string, opts metav1.GetOptions) (*Node, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *nodeClient2) Update(obj *Node) (*Node, error) { + return n.iface.Update(obj) +} + +func (n *nodeClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *nodeClient2) List(namespace string, opts metav1.ListOptions) (*NodeList, error) { + return n.iface.List(opts) +} + +func (n *nodeClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *nodeClientCache) Get(namespace, name string) (*Node, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *nodeClientCache) List(namespace string, selector labels.Selector) ([]*Node, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *nodeClient2) Cache() NodeClientCache { + n.loadController() + return &nodeClientCache{ + client: n, + } +} + +func (n *nodeClient2) OnCreate(ctx context.Context, name string, sync NodeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeLifecycleDelegate{create: sync}) +} + +func (n *nodeClient2) OnChange(ctx context.Context, name string, sync NodeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeLifecycleDelegate{update: sync}) +} + +func (n *nodeClient2) OnRemove(ctx context.Context, name string, sync NodeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeLifecycleDelegate{remove: sync}) +} + +func (n *nodeClientCache) Index(name string, indexer NodeIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Node); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *nodeClientCache) GetIndexed(name, key string) ([]*Node, error) { + var result []*Node + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Node); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *nodeClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type nodeLifecycleDelegate struct { + create NodeChangeHandlerFunc + update NodeChangeHandlerFunc + remove NodeChangeHandlerFunc +} + +func (n *nodeLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *nodeLifecycleDelegate) Create(obj *Node) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *nodeLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *nodeLifecycleDelegate) Remove(obj *Node) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *nodeLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *nodeLifecycleDelegate) Updated(obj *Node) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_node_driver_controller.go b/apis/management.cattle.io/v3/zz_generated_node_driver_controller.go index 73525d29..650c96b0 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_driver_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_node_driver_controller.go @@ -36,6 +36,8 @@ type NodeDriverList struct { type NodeDriverHandlerFunc func(key string, obj *NodeDriver) (runtime.Object, error) +type NodeDriverChangeHandlerFunc func(obj *NodeDriver) (runtime.Object, error) + type NodeDriverLister interface { List(namespace string, selector labels.Selector) (ret []*NodeDriver, err error) Get(namespace, name string) (*NodeDriver, error) @@ -247,3 +249,182 @@ func (s *nodeDriverClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewNodeDriverLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NodeDriverIndexer func(obj *NodeDriver) ([]string, error) + +type NodeDriverClientCache interface { + Get(namespace, name string) (*NodeDriver, error) + List(namespace string, selector labels.Selector) ([]*NodeDriver, error) + + Index(name string, indexer NodeDriverIndexer) + GetIndexed(name, key string) ([]*NodeDriver, error) +} + +type NodeDriverClient interface { + Create(*NodeDriver) (*NodeDriver, error) + Get(namespace, name string, opts metav1.GetOptions) (*NodeDriver, error) + Update(*NodeDriver) (*NodeDriver, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NodeDriverList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NodeDriverClientCache + + OnCreate(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NodeDriverInterface +} + +type nodeDriverClientCache struct { + client *nodeDriverClient2 +} + +type nodeDriverClient2 struct { + iface NodeDriverInterface + controller NodeDriverController +} + +func (n *nodeDriverClient2) Interface() NodeDriverInterface { + return n.iface +} + +func (n *nodeDriverClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *nodeDriverClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *nodeDriverClient2) Create(obj *NodeDriver) (*NodeDriver, error) { + return n.iface.Create(obj) +} + +func (n *nodeDriverClient2) Get(namespace, name string, opts metav1.GetOptions) (*NodeDriver, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *nodeDriverClient2) Update(obj *NodeDriver) (*NodeDriver, error) { + return n.iface.Update(obj) +} + +func (n *nodeDriverClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *nodeDriverClient2) List(namespace string, opts metav1.ListOptions) (*NodeDriverList, error) { + return n.iface.List(opts) +} + +func (n *nodeDriverClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *nodeDriverClientCache) Get(namespace, name string) (*NodeDriver, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *nodeDriverClientCache) List(namespace string, selector labels.Selector) ([]*NodeDriver, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *nodeDriverClient2) Cache() NodeDriverClientCache { + n.loadController() + return &nodeDriverClientCache{ + client: n, + } +} + +func (n *nodeDriverClient2) OnCreate(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeDriverLifecycleDelegate{create: sync}) +} + +func (n *nodeDriverClient2) OnChange(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeDriverLifecycleDelegate{update: sync}) +} + +func (n *nodeDriverClient2) OnRemove(ctx context.Context, name string, sync NodeDriverChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeDriverLifecycleDelegate{remove: sync}) +} + +func (n *nodeDriverClientCache) Index(name string, indexer NodeDriverIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NodeDriver); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *nodeDriverClientCache) GetIndexed(name, key string) ([]*NodeDriver, error) { + var result []*NodeDriver + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NodeDriver); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *nodeDriverClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type nodeDriverLifecycleDelegate struct { + create NodeDriverChangeHandlerFunc + update NodeDriverChangeHandlerFunc + remove NodeDriverChangeHandlerFunc +} + +func (n *nodeDriverLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *nodeDriverLifecycleDelegate) Create(obj *NodeDriver) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *nodeDriverLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *nodeDriverLifecycleDelegate) Remove(obj *NodeDriver) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *nodeDriverLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *nodeDriverLifecycleDelegate) Updated(obj *NodeDriver) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_node_pool_controller.go b/apis/management.cattle.io/v3/zz_generated_node_pool_controller.go index 4f487c39..ea24ae10 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_pool_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_node_pool_controller.go @@ -37,6 +37,8 @@ type NodePoolList struct { type NodePoolHandlerFunc func(key string, obj *NodePool) (runtime.Object, error) +type NodePoolChangeHandlerFunc func(obj *NodePool) (runtime.Object, error) + type NodePoolLister interface { List(namespace string, selector labels.Selector) (ret []*NodePool, err error) Get(namespace, name string) (*NodePool, error) @@ -248,3 +250,182 @@ func (s *nodePoolClient) AddClusterScopedLifecycle(ctx context.Context, name, cl sync := NewNodePoolLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NodePoolIndexer func(obj *NodePool) ([]string, error) + +type NodePoolClientCache interface { + Get(namespace, name string) (*NodePool, error) + List(namespace string, selector labels.Selector) ([]*NodePool, error) + + Index(name string, indexer NodePoolIndexer) + GetIndexed(name, key string) ([]*NodePool, error) +} + +type NodePoolClient interface { + Create(*NodePool) (*NodePool, error) + Get(namespace, name string, opts metav1.GetOptions) (*NodePool, error) + Update(*NodePool) (*NodePool, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NodePoolList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NodePoolClientCache + + OnCreate(ctx context.Context, name string, sync NodePoolChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NodePoolChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NodePoolChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NodePoolInterface +} + +type nodePoolClientCache struct { + client *nodePoolClient2 +} + +type nodePoolClient2 struct { + iface NodePoolInterface + controller NodePoolController +} + +func (n *nodePoolClient2) Interface() NodePoolInterface { + return n.iface +} + +func (n *nodePoolClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *nodePoolClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *nodePoolClient2) Create(obj *NodePool) (*NodePool, error) { + return n.iface.Create(obj) +} + +func (n *nodePoolClient2) Get(namespace, name string, opts metav1.GetOptions) (*NodePool, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *nodePoolClient2) Update(obj *NodePool) (*NodePool, error) { + return n.iface.Update(obj) +} + +func (n *nodePoolClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *nodePoolClient2) List(namespace string, opts metav1.ListOptions) (*NodePoolList, error) { + return n.iface.List(opts) +} + +func (n *nodePoolClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *nodePoolClientCache) Get(namespace, name string) (*NodePool, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *nodePoolClientCache) List(namespace string, selector labels.Selector) ([]*NodePool, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *nodePoolClient2) Cache() NodePoolClientCache { + n.loadController() + return &nodePoolClientCache{ + client: n, + } +} + +func (n *nodePoolClient2) OnCreate(ctx context.Context, name string, sync NodePoolChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodePoolLifecycleDelegate{create: sync}) +} + +func (n *nodePoolClient2) OnChange(ctx context.Context, name string, sync NodePoolChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodePoolLifecycleDelegate{update: sync}) +} + +func (n *nodePoolClient2) OnRemove(ctx context.Context, name string, sync NodePoolChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodePoolLifecycleDelegate{remove: sync}) +} + +func (n *nodePoolClientCache) Index(name string, indexer NodePoolIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NodePool); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *nodePoolClientCache) GetIndexed(name, key string) ([]*NodePool, error) { + var result []*NodePool + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NodePool); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *nodePoolClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type nodePoolLifecycleDelegate struct { + create NodePoolChangeHandlerFunc + update NodePoolChangeHandlerFunc + remove NodePoolChangeHandlerFunc +} + +func (n *nodePoolLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *nodePoolLifecycleDelegate) Create(obj *NodePool) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *nodePoolLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *nodePoolLifecycleDelegate) Remove(obj *NodePool) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *nodePoolLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *nodePoolLifecycleDelegate) Updated(obj *NodePool) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_node_template_controller.go b/apis/management.cattle.io/v3/zz_generated_node_template_controller.go index 83b4bd93..e894d727 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_template_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_node_template_controller.go @@ -37,6 +37,8 @@ type NodeTemplateList struct { type NodeTemplateHandlerFunc func(key string, obj *NodeTemplate) (runtime.Object, error) +type NodeTemplateChangeHandlerFunc func(obj *NodeTemplate) (runtime.Object, error) + type NodeTemplateLister interface { List(namespace string, selector labels.Selector) (ret []*NodeTemplate, err error) Get(namespace, name string) (*NodeTemplate, error) @@ -248,3 +250,182 @@ func (s *nodeTemplateClient) AddClusterScopedLifecycle(ctx context.Context, name sync := NewNodeTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NodeTemplateIndexer func(obj *NodeTemplate) ([]string, error) + +type NodeTemplateClientCache interface { + Get(namespace, name string) (*NodeTemplate, error) + List(namespace string, selector labels.Selector) ([]*NodeTemplate, error) + + Index(name string, indexer NodeTemplateIndexer) + GetIndexed(name, key string) ([]*NodeTemplate, error) +} + +type NodeTemplateClient interface { + Create(*NodeTemplate) (*NodeTemplate, error) + Get(namespace, name string, opts metav1.GetOptions) (*NodeTemplate, error) + Update(*NodeTemplate) (*NodeTemplate, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NodeTemplateList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NodeTemplateClientCache + + OnCreate(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NodeTemplateInterface +} + +type nodeTemplateClientCache struct { + client *nodeTemplateClient2 +} + +type nodeTemplateClient2 struct { + iface NodeTemplateInterface + controller NodeTemplateController +} + +func (n *nodeTemplateClient2) Interface() NodeTemplateInterface { + return n.iface +} + +func (n *nodeTemplateClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *nodeTemplateClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *nodeTemplateClient2) Create(obj *NodeTemplate) (*NodeTemplate, error) { + return n.iface.Create(obj) +} + +func (n *nodeTemplateClient2) Get(namespace, name string, opts metav1.GetOptions) (*NodeTemplate, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *nodeTemplateClient2) Update(obj *NodeTemplate) (*NodeTemplate, error) { + return n.iface.Update(obj) +} + +func (n *nodeTemplateClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *nodeTemplateClient2) List(namespace string, opts metav1.ListOptions) (*NodeTemplateList, error) { + return n.iface.List(opts) +} + +func (n *nodeTemplateClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *nodeTemplateClientCache) Get(namespace, name string) (*NodeTemplate, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *nodeTemplateClientCache) List(namespace string, selector labels.Selector) ([]*NodeTemplate, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *nodeTemplateClient2) Cache() NodeTemplateClientCache { + n.loadController() + return &nodeTemplateClientCache{ + client: n, + } +} + +func (n *nodeTemplateClient2) OnCreate(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeTemplateLifecycleDelegate{create: sync}) +} + +func (n *nodeTemplateClient2) OnChange(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeTemplateLifecycleDelegate{update: sync}) +} + +func (n *nodeTemplateClient2) OnRemove(ctx context.Context, name string, sync NodeTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &nodeTemplateLifecycleDelegate{remove: sync}) +} + +func (n *nodeTemplateClientCache) Index(name string, indexer NodeTemplateIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NodeTemplate); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *nodeTemplateClientCache) GetIndexed(name, key string) ([]*NodeTemplate, error) { + var result []*NodeTemplate + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NodeTemplate); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *nodeTemplateClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type nodeTemplateLifecycleDelegate struct { + create NodeTemplateChangeHandlerFunc + update NodeTemplateChangeHandlerFunc + remove NodeTemplateChangeHandlerFunc +} + +func (n *nodeTemplateLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *nodeTemplateLifecycleDelegate) Create(obj *NodeTemplate) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *nodeTemplateLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *nodeTemplateLifecycleDelegate) Remove(obj *NodeTemplate) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *nodeTemplateLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *nodeTemplateLifecycleDelegate) Updated(obj *NodeTemplate) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_notifier_controller.go b/apis/management.cattle.io/v3/zz_generated_notifier_controller.go index 0dd439c7..f3a328cd 100644 --- a/apis/management.cattle.io/v3/zz_generated_notifier_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_notifier_controller.go @@ -37,6 +37,8 @@ type NotifierList struct { type NotifierHandlerFunc func(key string, obj *Notifier) (runtime.Object, error) +type NotifierChangeHandlerFunc func(obj *Notifier) (runtime.Object, error) + type NotifierLister interface { List(namespace string, selector labels.Selector) (ret []*Notifier, err error) Get(namespace, name string) (*Notifier, error) @@ -248,3 +250,182 @@ func (s *notifierClient) AddClusterScopedLifecycle(ctx context.Context, name, cl sync := NewNotifierLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NotifierIndexer func(obj *Notifier) ([]string, error) + +type NotifierClientCache interface { + Get(namespace, name string) (*Notifier, error) + List(namespace string, selector labels.Selector) ([]*Notifier, error) + + Index(name string, indexer NotifierIndexer) + GetIndexed(name, key string) ([]*Notifier, error) +} + +type NotifierClient interface { + Create(*Notifier) (*Notifier, error) + Get(namespace, name string, opts metav1.GetOptions) (*Notifier, error) + Update(*Notifier) (*Notifier, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NotifierList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NotifierClientCache + + OnCreate(ctx context.Context, name string, sync NotifierChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NotifierChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NotifierChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NotifierInterface +} + +type notifierClientCache struct { + client *notifierClient2 +} + +type notifierClient2 struct { + iface NotifierInterface + controller NotifierController +} + +func (n *notifierClient2) Interface() NotifierInterface { + return n.iface +} + +func (n *notifierClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *notifierClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *notifierClient2) Create(obj *Notifier) (*Notifier, error) { + return n.iface.Create(obj) +} + +func (n *notifierClient2) Get(namespace, name string, opts metav1.GetOptions) (*Notifier, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *notifierClient2) Update(obj *Notifier) (*Notifier, error) { + return n.iface.Update(obj) +} + +func (n *notifierClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *notifierClient2) List(namespace string, opts metav1.ListOptions) (*NotifierList, error) { + return n.iface.List(opts) +} + +func (n *notifierClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *notifierClientCache) Get(namespace, name string) (*Notifier, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *notifierClientCache) List(namespace string, selector labels.Selector) ([]*Notifier, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *notifierClient2) Cache() NotifierClientCache { + n.loadController() + return ¬ifierClientCache{ + client: n, + } +} + +func (n *notifierClient2) OnCreate(ctx context.Context, name string, sync NotifierChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, ¬ifierLifecycleDelegate{create: sync}) +} + +func (n *notifierClient2) OnChange(ctx context.Context, name string, sync NotifierChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, ¬ifierLifecycleDelegate{update: sync}) +} + +func (n *notifierClient2) OnRemove(ctx context.Context, name string, sync NotifierChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, ¬ifierLifecycleDelegate{remove: sync}) +} + +func (n *notifierClientCache) Index(name string, indexer NotifierIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Notifier); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *notifierClientCache) GetIndexed(name, key string) ([]*Notifier, error) { + var result []*Notifier + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Notifier); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *notifierClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type notifierLifecycleDelegate struct { + create NotifierChangeHandlerFunc + update NotifierChangeHandlerFunc + remove NotifierChangeHandlerFunc +} + +func (n *notifierLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *notifierLifecycleDelegate) Create(obj *Notifier) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *notifierLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *notifierLifecycleDelegate) Remove(obj *Notifier) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *notifierLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *notifierLifecycleDelegate) Updated(obj *Notifier) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_controller.go b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_controller.go index 6084487d..1929ed6e 100644 --- a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_controller.go @@ -36,6 +36,8 @@ type PodSecurityPolicyTemplateList struct { type PodSecurityPolicyTemplateHandlerFunc func(key string, obj *PodSecurityPolicyTemplate) (runtime.Object, error) +type PodSecurityPolicyTemplateChangeHandlerFunc func(obj *PodSecurityPolicyTemplate) (runtime.Object, error) + type PodSecurityPolicyTemplateLister interface { List(namespace string, selector labels.Selector) (ret []*PodSecurityPolicyTemplate, err error) Get(namespace, name string) (*PodSecurityPolicyTemplate, error) @@ -247,3 +249,182 @@ func (s *podSecurityPolicyTemplateClient) AddClusterScopedLifecycle(ctx context. sync := NewPodSecurityPolicyTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PodSecurityPolicyTemplateIndexer func(obj *PodSecurityPolicyTemplate) ([]string, error) + +type PodSecurityPolicyTemplateClientCache interface { + Get(namespace, name string) (*PodSecurityPolicyTemplate, error) + List(namespace string, selector labels.Selector) ([]*PodSecurityPolicyTemplate, error) + + Index(name string, indexer PodSecurityPolicyTemplateIndexer) + GetIndexed(name, key string) ([]*PodSecurityPolicyTemplate, error) +} + +type PodSecurityPolicyTemplateClient interface { + Create(*PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error) + Get(namespace, name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplate, error) + Update(*PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyTemplateList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PodSecurityPolicyTemplateClientCache + + OnCreate(ctx context.Context, name string, sync PodSecurityPolicyTemplateChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PodSecurityPolicyTemplateChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PodSecurityPolicyTemplateChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PodSecurityPolicyTemplateInterface +} + +type podSecurityPolicyTemplateClientCache struct { + client *podSecurityPolicyTemplateClient2 +} + +type podSecurityPolicyTemplateClient2 struct { + iface PodSecurityPolicyTemplateInterface + controller PodSecurityPolicyTemplateController +} + +func (n *podSecurityPolicyTemplateClient2) Interface() PodSecurityPolicyTemplateInterface { + return n.iface +} + +func (n *podSecurityPolicyTemplateClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *podSecurityPolicyTemplateClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *podSecurityPolicyTemplateClient2) Create(obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error) { + return n.iface.Create(obj) +} + +func (n *podSecurityPolicyTemplateClient2) Get(namespace, name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplate, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *podSecurityPolicyTemplateClient2) Update(obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error) { + return n.iface.Update(obj) +} + +func (n *podSecurityPolicyTemplateClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *podSecurityPolicyTemplateClient2) List(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyTemplateList, error) { + return n.iface.List(opts) +} + +func (n *podSecurityPolicyTemplateClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *podSecurityPolicyTemplateClientCache) Get(namespace, name string) (*PodSecurityPolicyTemplate, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *podSecurityPolicyTemplateClientCache) List(namespace string, selector labels.Selector) ([]*PodSecurityPolicyTemplate, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *podSecurityPolicyTemplateClient2) Cache() PodSecurityPolicyTemplateClientCache { + n.loadController() + return &podSecurityPolicyTemplateClientCache{ + client: n, + } +} + +func (n *podSecurityPolicyTemplateClient2) OnCreate(ctx context.Context, name string, sync PodSecurityPolicyTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyTemplateLifecycleDelegate{create: sync}) +} + +func (n *podSecurityPolicyTemplateClient2) OnChange(ctx context.Context, name string, sync PodSecurityPolicyTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyTemplateLifecycleDelegate{update: sync}) +} + +func (n *podSecurityPolicyTemplateClient2) OnRemove(ctx context.Context, name string, sync PodSecurityPolicyTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyTemplateLifecycleDelegate{remove: sync}) +} + +func (n *podSecurityPolicyTemplateClientCache) Index(name string, indexer PodSecurityPolicyTemplateIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*PodSecurityPolicyTemplate); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *podSecurityPolicyTemplateClientCache) GetIndexed(name, key string) ([]*PodSecurityPolicyTemplate, error) { + var result []*PodSecurityPolicyTemplate + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*PodSecurityPolicyTemplate); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *podSecurityPolicyTemplateClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type podSecurityPolicyTemplateLifecycleDelegate struct { + create PodSecurityPolicyTemplateChangeHandlerFunc + update PodSecurityPolicyTemplateChangeHandlerFunc + remove PodSecurityPolicyTemplateChangeHandlerFunc +} + +func (n *podSecurityPolicyTemplateLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *podSecurityPolicyTemplateLifecycleDelegate) Create(obj *PodSecurityPolicyTemplate) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *podSecurityPolicyTemplateLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *podSecurityPolicyTemplateLifecycleDelegate) Remove(obj *PodSecurityPolicyTemplate) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *podSecurityPolicyTemplateLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *podSecurityPolicyTemplateLifecycleDelegate) Updated(obj *PodSecurityPolicyTemplate) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_controller.go b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_controller.go index e6a70f71..48b47649 100644 --- a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_controller.go @@ -37,6 +37,8 @@ type PodSecurityPolicyTemplateProjectBindingList struct { type PodSecurityPolicyTemplateProjectBindingHandlerFunc func(key string, obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error) +type PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc func(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error) + type PodSecurityPolicyTemplateProjectBindingLister interface { List(namespace string, selector labels.Selector) (ret []*PodSecurityPolicyTemplateProjectBinding, err error) Get(namespace, name string) (*PodSecurityPolicyTemplateProjectBinding, error) @@ -248,3 +250,182 @@ func (s *podSecurityPolicyTemplateProjectBindingClient) AddClusterScopedLifecycl sync := NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PodSecurityPolicyTemplateProjectBindingIndexer func(obj *PodSecurityPolicyTemplateProjectBinding) ([]string, error) + +type PodSecurityPolicyTemplateProjectBindingClientCache interface { + Get(namespace, name string) (*PodSecurityPolicyTemplateProjectBinding, error) + List(namespace string, selector labels.Selector) ([]*PodSecurityPolicyTemplateProjectBinding, error) + + Index(name string, indexer PodSecurityPolicyTemplateProjectBindingIndexer) + GetIndexed(name, key string) ([]*PodSecurityPolicyTemplateProjectBinding, error) +} + +type PodSecurityPolicyTemplateProjectBindingClient interface { + Create(*PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error) + Get(namespace, name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplateProjectBinding, error) + Update(*PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyTemplateProjectBindingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PodSecurityPolicyTemplateProjectBindingClientCache + + OnCreate(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PodSecurityPolicyTemplateProjectBindingInterface +} + +type podSecurityPolicyTemplateProjectBindingClientCache struct { + client *podSecurityPolicyTemplateProjectBindingClient2 +} + +type podSecurityPolicyTemplateProjectBindingClient2 struct { + iface PodSecurityPolicyTemplateProjectBindingInterface + controller PodSecurityPolicyTemplateProjectBindingController +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Interface() PodSecurityPolicyTemplateProjectBindingInterface { + return n.iface +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Create(obj *PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error) { + return n.iface.Create(obj) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Get(namespace, name string, opts metav1.GetOptions) (*PodSecurityPolicyTemplateProjectBinding, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Update(obj *PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error) { + return n.iface.Update(obj) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) List(namespace string, opts metav1.ListOptions) (*PodSecurityPolicyTemplateProjectBindingList, error) { + return n.iface.List(opts) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *podSecurityPolicyTemplateProjectBindingClientCache) Get(namespace, name string) (*PodSecurityPolicyTemplateProjectBinding, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *podSecurityPolicyTemplateProjectBindingClientCache) List(namespace string, selector labels.Selector) ([]*PodSecurityPolicyTemplateProjectBinding, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) Cache() PodSecurityPolicyTemplateProjectBindingClientCache { + n.loadController() + return &podSecurityPolicyTemplateProjectBindingClientCache{ + client: n, + } +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) OnCreate(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyTemplateProjectBindingLifecycleDelegate{create: sync}) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) OnChange(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyTemplateProjectBindingLifecycleDelegate{update: sync}) +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) OnRemove(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &podSecurityPolicyTemplateProjectBindingLifecycleDelegate{remove: sync}) +} + +func (n *podSecurityPolicyTemplateProjectBindingClientCache) Index(name string, indexer PodSecurityPolicyTemplateProjectBindingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*PodSecurityPolicyTemplateProjectBinding); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *podSecurityPolicyTemplateProjectBindingClientCache) GetIndexed(name, key string) ([]*PodSecurityPolicyTemplateProjectBinding, error) { + var result []*PodSecurityPolicyTemplateProjectBinding + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*PodSecurityPolicyTemplateProjectBinding); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *podSecurityPolicyTemplateProjectBindingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type podSecurityPolicyTemplateProjectBindingLifecycleDelegate struct { + create PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc + update PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc + remove PodSecurityPolicyTemplateProjectBindingChangeHandlerFunc +} + +func (n *podSecurityPolicyTemplateProjectBindingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *podSecurityPolicyTemplateProjectBindingLifecycleDelegate) Create(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *podSecurityPolicyTemplateProjectBindingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *podSecurityPolicyTemplateProjectBindingLifecycleDelegate) Remove(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *podSecurityPolicyTemplateProjectBindingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *podSecurityPolicyTemplateProjectBindingLifecycleDelegate) Updated(obj *PodSecurityPolicyTemplateProjectBinding) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_preference_controller.go b/apis/management.cattle.io/v3/zz_generated_preference_controller.go index 341b0ba4..93a5cb78 100644 --- a/apis/management.cattle.io/v3/zz_generated_preference_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_preference_controller.go @@ -37,6 +37,8 @@ type PreferenceList struct { type PreferenceHandlerFunc func(key string, obj *Preference) (runtime.Object, error) +type PreferenceChangeHandlerFunc func(obj *Preference) (runtime.Object, error) + type PreferenceLister interface { List(namespace string, selector labels.Selector) (ret []*Preference, err error) Get(namespace, name string) (*Preference, error) @@ -248,3 +250,182 @@ func (s *preferenceClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewPreferenceLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PreferenceIndexer func(obj *Preference) ([]string, error) + +type PreferenceClientCache interface { + Get(namespace, name string) (*Preference, error) + List(namespace string, selector labels.Selector) ([]*Preference, error) + + Index(name string, indexer PreferenceIndexer) + GetIndexed(name, key string) ([]*Preference, error) +} + +type PreferenceClient interface { + Create(*Preference) (*Preference, error) + Get(namespace, name string, opts metav1.GetOptions) (*Preference, error) + Update(*Preference) (*Preference, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PreferenceList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PreferenceClientCache + + OnCreate(ctx context.Context, name string, sync PreferenceChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PreferenceChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PreferenceChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PreferenceInterface +} + +type preferenceClientCache struct { + client *preferenceClient2 +} + +type preferenceClient2 struct { + iface PreferenceInterface + controller PreferenceController +} + +func (n *preferenceClient2) Interface() PreferenceInterface { + return n.iface +} + +func (n *preferenceClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *preferenceClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *preferenceClient2) Create(obj *Preference) (*Preference, error) { + return n.iface.Create(obj) +} + +func (n *preferenceClient2) Get(namespace, name string, opts metav1.GetOptions) (*Preference, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *preferenceClient2) Update(obj *Preference) (*Preference, error) { + return n.iface.Update(obj) +} + +func (n *preferenceClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *preferenceClient2) List(namespace string, opts metav1.ListOptions) (*PreferenceList, error) { + return n.iface.List(opts) +} + +func (n *preferenceClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *preferenceClientCache) Get(namespace, name string) (*Preference, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *preferenceClientCache) List(namespace string, selector labels.Selector) ([]*Preference, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *preferenceClient2) Cache() PreferenceClientCache { + n.loadController() + return &preferenceClientCache{ + client: n, + } +} + +func (n *preferenceClient2) OnCreate(ctx context.Context, name string, sync PreferenceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &preferenceLifecycleDelegate{create: sync}) +} + +func (n *preferenceClient2) OnChange(ctx context.Context, name string, sync PreferenceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &preferenceLifecycleDelegate{update: sync}) +} + +func (n *preferenceClient2) OnRemove(ctx context.Context, name string, sync PreferenceChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &preferenceLifecycleDelegate{remove: sync}) +} + +func (n *preferenceClientCache) Index(name string, indexer PreferenceIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Preference); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *preferenceClientCache) GetIndexed(name, key string) ([]*Preference, error) { + var result []*Preference + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Preference); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *preferenceClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type preferenceLifecycleDelegate struct { + create PreferenceChangeHandlerFunc + update PreferenceChangeHandlerFunc + remove PreferenceChangeHandlerFunc +} + +func (n *preferenceLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *preferenceLifecycleDelegate) Create(obj *Preference) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *preferenceLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *preferenceLifecycleDelegate) Remove(obj *Preference) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *preferenceLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *preferenceLifecycleDelegate) Updated(obj *Preference) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_principal_controller.go b/apis/management.cattle.io/v3/zz_generated_principal_controller.go index 855ac47c..7154a2bd 100644 --- a/apis/management.cattle.io/v3/zz_generated_principal_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_principal_controller.go @@ -36,6 +36,8 @@ type PrincipalList struct { type PrincipalHandlerFunc func(key string, obj *Principal) (runtime.Object, error) +type PrincipalChangeHandlerFunc func(obj *Principal) (runtime.Object, error) + type PrincipalLister interface { List(namespace string, selector labels.Selector) (ret []*Principal, err error) Get(namespace, name string) (*Principal, error) @@ -247,3 +249,182 @@ func (s *principalClient) AddClusterScopedLifecycle(ctx context.Context, name, c sync := NewPrincipalLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PrincipalIndexer func(obj *Principal) ([]string, error) + +type PrincipalClientCache interface { + Get(namespace, name string) (*Principal, error) + List(namespace string, selector labels.Selector) ([]*Principal, error) + + Index(name string, indexer PrincipalIndexer) + GetIndexed(name, key string) ([]*Principal, error) +} + +type PrincipalClient interface { + Create(*Principal) (*Principal, error) + Get(namespace, name string, opts metav1.GetOptions) (*Principal, error) + Update(*Principal) (*Principal, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PrincipalList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PrincipalClientCache + + OnCreate(ctx context.Context, name string, sync PrincipalChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PrincipalChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PrincipalChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PrincipalInterface +} + +type principalClientCache struct { + client *principalClient2 +} + +type principalClient2 struct { + iface PrincipalInterface + controller PrincipalController +} + +func (n *principalClient2) Interface() PrincipalInterface { + return n.iface +} + +func (n *principalClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *principalClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *principalClient2) Create(obj *Principal) (*Principal, error) { + return n.iface.Create(obj) +} + +func (n *principalClient2) Get(namespace, name string, opts metav1.GetOptions) (*Principal, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *principalClient2) Update(obj *Principal) (*Principal, error) { + return n.iface.Update(obj) +} + +func (n *principalClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *principalClient2) List(namespace string, opts metav1.ListOptions) (*PrincipalList, error) { + return n.iface.List(opts) +} + +func (n *principalClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *principalClientCache) Get(namespace, name string) (*Principal, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *principalClientCache) List(namespace string, selector labels.Selector) ([]*Principal, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *principalClient2) Cache() PrincipalClientCache { + n.loadController() + return &principalClientCache{ + client: n, + } +} + +func (n *principalClient2) OnCreate(ctx context.Context, name string, sync PrincipalChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &principalLifecycleDelegate{create: sync}) +} + +func (n *principalClient2) OnChange(ctx context.Context, name string, sync PrincipalChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &principalLifecycleDelegate{update: sync}) +} + +func (n *principalClient2) OnRemove(ctx context.Context, name string, sync PrincipalChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &principalLifecycleDelegate{remove: sync}) +} + +func (n *principalClientCache) Index(name string, indexer PrincipalIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Principal); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *principalClientCache) GetIndexed(name, key string) ([]*Principal, error) { + var result []*Principal + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Principal); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *principalClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type principalLifecycleDelegate struct { + create PrincipalChangeHandlerFunc + update PrincipalChangeHandlerFunc + remove PrincipalChangeHandlerFunc +} + +func (n *principalLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *principalLifecycleDelegate) Create(obj *Principal) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *principalLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *principalLifecycleDelegate) Remove(obj *Principal) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *principalLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *principalLifecycleDelegate) Updated(obj *Principal) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_project_alert_controller.go b/apis/management.cattle.io/v3/zz_generated_project_alert_controller.go index ab20ce03..40dfabc4 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_alert_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_alert_controller.go @@ -37,6 +37,8 @@ type ProjectAlertList struct { type ProjectAlertHandlerFunc func(key string, obj *ProjectAlert) (runtime.Object, error) +type ProjectAlertChangeHandlerFunc func(obj *ProjectAlert) (runtime.Object, error) + type ProjectAlertLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectAlert, err error) Get(namespace, name string) (*ProjectAlert, error) @@ -248,3 +250,182 @@ func (s *projectAlertClient) AddClusterScopedLifecycle(ctx context.Context, name sync := NewProjectAlertLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ProjectAlertIndexer func(obj *ProjectAlert) ([]string, error) + +type ProjectAlertClientCache interface { + Get(namespace, name string) (*ProjectAlert, error) + List(namespace string, selector labels.Selector) ([]*ProjectAlert, error) + + Index(name string, indexer ProjectAlertIndexer) + GetIndexed(name, key string) ([]*ProjectAlert, error) +} + +type ProjectAlertClient interface { + Create(*ProjectAlert) (*ProjectAlert, error) + Get(namespace, name string, opts metav1.GetOptions) (*ProjectAlert, error) + Update(*ProjectAlert) (*ProjectAlert, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ProjectAlertList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ProjectAlertClientCache + + OnCreate(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ProjectAlertInterface +} + +type projectAlertClientCache struct { + client *projectAlertClient2 +} + +type projectAlertClient2 struct { + iface ProjectAlertInterface + controller ProjectAlertController +} + +func (n *projectAlertClient2) Interface() ProjectAlertInterface { + return n.iface +} + +func (n *projectAlertClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *projectAlertClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *projectAlertClient2) Create(obj *ProjectAlert) (*ProjectAlert, error) { + return n.iface.Create(obj) +} + +func (n *projectAlertClient2) Get(namespace, name string, opts metav1.GetOptions) (*ProjectAlert, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *projectAlertClient2) Update(obj *ProjectAlert) (*ProjectAlert, error) { + return n.iface.Update(obj) +} + +func (n *projectAlertClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *projectAlertClient2) List(namespace string, opts metav1.ListOptions) (*ProjectAlertList, error) { + return n.iface.List(opts) +} + +func (n *projectAlertClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *projectAlertClientCache) Get(namespace, name string) (*ProjectAlert, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *projectAlertClientCache) List(namespace string, selector labels.Selector) ([]*ProjectAlert, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *projectAlertClient2) Cache() ProjectAlertClientCache { + n.loadController() + return &projectAlertClientCache{ + client: n, + } +} + +func (n *projectAlertClient2) OnCreate(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectAlertLifecycleDelegate{create: sync}) +} + +func (n *projectAlertClient2) OnChange(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectAlertLifecycleDelegate{update: sync}) +} + +func (n *projectAlertClient2) OnRemove(ctx context.Context, name string, sync ProjectAlertChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectAlertLifecycleDelegate{remove: sync}) +} + +func (n *projectAlertClientCache) Index(name string, indexer ProjectAlertIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ProjectAlert); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *projectAlertClientCache) GetIndexed(name, key string) ([]*ProjectAlert, error) { + var result []*ProjectAlert + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ProjectAlert); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *projectAlertClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type projectAlertLifecycleDelegate struct { + create ProjectAlertChangeHandlerFunc + update ProjectAlertChangeHandlerFunc + remove ProjectAlertChangeHandlerFunc +} + +func (n *projectAlertLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *projectAlertLifecycleDelegate) Create(obj *ProjectAlert) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *projectAlertLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *projectAlertLifecycleDelegate) Remove(obj *ProjectAlert) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *projectAlertLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *projectAlertLifecycleDelegate) Updated(obj *ProjectAlert) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_project_catalog_controller.go b/apis/management.cattle.io/v3/zz_generated_project_catalog_controller.go index ffc503a5..19adb9cb 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_catalog_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_catalog_controller.go @@ -37,6 +37,8 @@ type ProjectCatalogList struct { type ProjectCatalogHandlerFunc func(key string, obj *ProjectCatalog) (runtime.Object, error) +type ProjectCatalogChangeHandlerFunc func(obj *ProjectCatalog) (runtime.Object, error) + type ProjectCatalogLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectCatalog, err error) Get(namespace, name string) (*ProjectCatalog, error) @@ -248,3 +250,182 @@ func (s *projectCatalogClient) AddClusterScopedLifecycle(ctx context.Context, na sync := NewProjectCatalogLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ProjectCatalogIndexer func(obj *ProjectCatalog) ([]string, error) + +type ProjectCatalogClientCache interface { + Get(namespace, name string) (*ProjectCatalog, error) + List(namespace string, selector labels.Selector) ([]*ProjectCatalog, error) + + Index(name string, indexer ProjectCatalogIndexer) + GetIndexed(name, key string) ([]*ProjectCatalog, error) +} + +type ProjectCatalogClient interface { + Create(*ProjectCatalog) (*ProjectCatalog, error) + Get(namespace, name string, opts metav1.GetOptions) (*ProjectCatalog, error) + Update(*ProjectCatalog) (*ProjectCatalog, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ProjectCatalogList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ProjectCatalogClientCache + + OnCreate(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ProjectCatalogInterface +} + +type projectCatalogClientCache struct { + client *projectCatalogClient2 +} + +type projectCatalogClient2 struct { + iface ProjectCatalogInterface + controller ProjectCatalogController +} + +func (n *projectCatalogClient2) Interface() ProjectCatalogInterface { + return n.iface +} + +func (n *projectCatalogClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *projectCatalogClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *projectCatalogClient2) Create(obj *ProjectCatalog) (*ProjectCatalog, error) { + return n.iface.Create(obj) +} + +func (n *projectCatalogClient2) Get(namespace, name string, opts metav1.GetOptions) (*ProjectCatalog, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *projectCatalogClient2) Update(obj *ProjectCatalog) (*ProjectCatalog, error) { + return n.iface.Update(obj) +} + +func (n *projectCatalogClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *projectCatalogClient2) List(namespace string, opts metav1.ListOptions) (*ProjectCatalogList, error) { + return n.iface.List(opts) +} + +func (n *projectCatalogClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *projectCatalogClientCache) Get(namespace, name string) (*ProjectCatalog, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *projectCatalogClientCache) List(namespace string, selector labels.Selector) ([]*ProjectCatalog, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *projectCatalogClient2) Cache() ProjectCatalogClientCache { + n.loadController() + return &projectCatalogClientCache{ + client: n, + } +} + +func (n *projectCatalogClient2) OnCreate(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectCatalogLifecycleDelegate{create: sync}) +} + +func (n *projectCatalogClient2) OnChange(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectCatalogLifecycleDelegate{update: sync}) +} + +func (n *projectCatalogClient2) OnRemove(ctx context.Context, name string, sync ProjectCatalogChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectCatalogLifecycleDelegate{remove: sync}) +} + +func (n *projectCatalogClientCache) Index(name string, indexer ProjectCatalogIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ProjectCatalog); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *projectCatalogClientCache) GetIndexed(name, key string) ([]*ProjectCatalog, error) { + var result []*ProjectCatalog + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ProjectCatalog); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *projectCatalogClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type projectCatalogLifecycleDelegate struct { + create ProjectCatalogChangeHandlerFunc + update ProjectCatalogChangeHandlerFunc + remove ProjectCatalogChangeHandlerFunc +} + +func (n *projectCatalogLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *projectCatalogLifecycleDelegate) Create(obj *ProjectCatalog) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *projectCatalogLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *projectCatalogLifecycleDelegate) Remove(obj *ProjectCatalog) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *projectCatalogLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *projectCatalogLifecycleDelegate) Updated(obj *ProjectCatalog) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_project_controller.go b/apis/management.cattle.io/v3/zz_generated_project_controller.go index 3f23a341..a146e99d 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_controller.go @@ -37,6 +37,8 @@ type ProjectList struct { type ProjectHandlerFunc func(key string, obj *Project) (runtime.Object, error) +type ProjectChangeHandlerFunc func(obj *Project) (runtime.Object, error) + type ProjectLister interface { List(namespace string, selector labels.Selector) (ret []*Project, err error) Get(namespace, name string) (*Project, error) @@ -248,3 +250,182 @@ func (s *projectClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewProjectLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ProjectIndexer func(obj *Project) ([]string, error) + +type ProjectClientCache interface { + Get(namespace, name string) (*Project, error) + List(namespace string, selector labels.Selector) ([]*Project, error) + + Index(name string, indexer ProjectIndexer) + GetIndexed(name, key string) ([]*Project, error) +} + +type ProjectClient interface { + Create(*Project) (*Project, error) + Get(namespace, name string, opts metav1.GetOptions) (*Project, error) + Update(*Project) (*Project, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ProjectList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ProjectClientCache + + OnCreate(ctx context.Context, name string, sync ProjectChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ProjectChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ProjectChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ProjectInterface +} + +type projectClientCache struct { + client *projectClient2 +} + +type projectClient2 struct { + iface ProjectInterface + controller ProjectController +} + +func (n *projectClient2) Interface() ProjectInterface { + return n.iface +} + +func (n *projectClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *projectClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *projectClient2) Create(obj *Project) (*Project, error) { + return n.iface.Create(obj) +} + +func (n *projectClient2) Get(namespace, name string, opts metav1.GetOptions) (*Project, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *projectClient2) Update(obj *Project) (*Project, error) { + return n.iface.Update(obj) +} + +func (n *projectClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *projectClient2) List(namespace string, opts metav1.ListOptions) (*ProjectList, error) { + return n.iface.List(opts) +} + +func (n *projectClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *projectClientCache) Get(namespace, name string) (*Project, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *projectClientCache) List(namespace string, selector labels.Selector) ([]*Project, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *projectClient2) Cache() ProjectClientCache { + n.loadController() + return &projectClientCache{ + client: n, + } +} + +func (n *projectClient2) OnCreate(ctx context.Context, name string, sync ProjectChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectLifecycleDelegate{create: sync}) +} + +func (n *projectClient2) OnChange(ctx context.Context, name string, sync ProjectChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectLifecycleDelegate{update: sync}) +} + +func (n *projectClient2) OnRemove(ctx context.Context, name string, sync ProjectChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectLifecycleDelegate{remove: sync}) +} + +func (n *projectClientCache) Index(name string, indexer ProjectIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Project); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *projectClientCache) GetIndexed(name, key string) ([]*Project, error) { + var result []*Project + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Project); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *projectClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type projectLifecycleDelegate struct { + create ProjectChangeHandlerFunc + update ProjectChangeHandlerFunc + remove ProjectChangeHandlerFunc +} + +func (n *projectLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *projectLifecycleDelegate) Create(obj *Project) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *projectLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *projectLifecycleDelegate) Remove(obj *Project) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *projectLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *projectLifecycleDelegate) Updated(obj *Project) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_project_logging_controller.go b/apis/management.cattle.io/v3/zz_generated_project_logging_controller.go index 68de5264..a11b324d 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_logging_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_logging_controller.go @@ -37,6 +37,8 @@ type ProjectLoggingList struct { type ProjectLoggingHandlerFunc func(key string, obj *ProjectLogging) (runtime.Object, error) +type ProjectLoggingChangeHandlerFunc func(obj *ProjectLogging) (runtime.Object, error) + type ProjectLoggingLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectLogging, err error) Get(namespace, name string) (*ProjectLogging, error) @@ -248,3 +250,182 @@ func (s *projectLoggingClient) AddClusterScopedLifecycle(ctx context.Context, na sync := NewProjectLoggingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ProjectLoggingIndexer func(obj *ProjectLogging) ([]string, error) + +type ProjectLoggingClientCache interface { + Get(namespace, name string) (*ProjectLogging, error) + List(namespace string, selector labels.Selector) ([]*ProjectLogging, error) + + Index(name string, indexer ProjectLoggingIndexer) + GetIndexed(name, key string) ([]*ProjectLogging, error) +} + +type ProjectLoggingClient interface { + Create(*ProjectLogging) (*ProjectLogging, error) + Get(namespace, name string, opts metav1.GetOptions) (*ProjectLogging, error) + Update(*ProjectLogging) (*ProjectLogging, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ProjectLoggingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ProjectLoggingClientCache + + OnCreate(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ProjectLoggingInterface +} + +type projectLoggingClientCache struct { + client *projectLoggingClient2 +} + +type projectLoggingClient2 struct { + iface ProjectLoggingInterface + controller ProjectLoggingController +} + +func (n *projectLoggingClient2) Interface() ProjectLoggingInterface { + return n.iface +} + +func (n *projectLoggingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *projectLoggingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *projectLoggingClient2) Create(obj *ProjectLogging) (*ProjectLogging, error) { + return n.iface.Create(obj) +} + +func (n *projectLoggingClient2) Get(namespace, name string, opts metav1.GetOptions) (*ProjectLogging, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *projectLoggingClient2) Update(obj *ProjectLogging) (*ProjectLogging, error) { + return n.iface.Update(obj) +} + +func (n *projectLoggingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *projectLoggingClient2) List(namespace string, opts metav1.ListOptions) (*ProjectLoggingList, error) { + return n.iface.List(opts) +} + +func (n *projectLoggingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *projectLoggingClientCache) Get(namespace, name string) (*ProjectLogging, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *projectLoggingClientCache) List(namespace string, selector labels.Selector) ([]*ProjectLogging, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *projectLoggingClient2) Cache() ProjectLoggingClientCache { + n.loadController() + return &projectLoggingClientCache{ + client: n, + } +} + +func (n *projectLoggingClient2) OnCreate(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectLoggingLifecycleDelegate{create: sync}) +} + +func (n *projectLoggingClient2) OnChange(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectLoggingLifecycleDelegate{update: sync}) +} + +func (n *projectLoggingClient2) OnRemove(ctx context.Context, name string, sync ProjectLoggingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectLoggingLifecycleDelegate{remove: sync}) +} + +func (n *projectLoggingClientCache) Index(name string, indexer ProjectLoggingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ProjectLogging); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *projectLoggingClientCache) GetIndexed(name, key string) ([]*ProjectLogging, error) { + var result []*ProjectLogging + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ProjectLogging); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *projectLoggingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type projectLoggingLifecycleDelegate struct { + create ProjectLoggingChangeHandlerFunc + update ProjectLoggingChangeHandlerFunc + remove ProjectLoggingChangeHandlerFunc +} + +func (n *projectLoggingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *projectLoggingLifecycleDelegate) Create(obj *ProjectLogging) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *projectLoggingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *projectLoggingLifecycleDelegate) Remove(obj *ProjectLogging) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *projectLoggingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *projectLoggingLifecycleDelegate) Updated(obj *ProjectLogging) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_project_network_policy_controller.go b/apis/management.cattle.io/v3/zz_generated_project_network_policy_controller.go index a59a9e26..ea8a539c 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_network_policy_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_network_policy_controller.go @@ -37,6 +37,8 @@ type ProjectNetworkPolicyList struct { type ProjectNetworkPolicyHandlerFunc func(key string, obj *ProjectNetworkPolicy) (runtime.Object, error) +type ProjectNetworkPolicyChangeHandlerFunc func(obj *ProjectNetworkPolicy) (runtime.Object, error) + type ProjectNetworkPolicyLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectNetworkPolicy, err error) Get(namespace, name string) (*ProjectNetworkPolicy, error) @@ -248,3 +250,182 @@ func (s *projectNetworkPolicyClient) AddClusterScopedLifecycle(ctx context.Conte sync := NewProjectNetworkPolicyLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ProjectNetworkPolicyIndexer func(obj *ProjectNetworkPolicy) ([]string, error) + +type ProjectNetworkPolicyClientCache interface { + Get(namespace, name string) (*ProjectNetworkPolicy, error) + List(namespace string, selector labels.Selector) ([]*ProjectNetworkPolicy, error) + + Index(name string, indexer ProjectNetworkPolicyIndexer) + GetIndexed(name, key string) ([]*ProjectNetworkPolicy, error) +} + +type ProjectNetworkPolicyClient interface { + Create(*ProjectNetworkPolicy) (*ProjectNetworkPolicy, error) + Get(namespace, name string, opts metav1.GetOptions) (*ProjectNetworkPolicy, error) + Update(*ProjectNetworkPolicy) (*ProjectNetworkPolicy, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ProjectNetworkPolicyList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ProjectNetworkPolicyClientCache + + OnCreate(ctx context.Context, name string, sync ProjectNetworkPolicyChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ProjectNetworkPolicyChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ProjectNetworkPolicyChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ProjectNetworkPolicyInterface +} + +type projectNetworkPolicyClientCache struct { + client *projectNetworkPolicyClient2 +} + +type projectNetworkPolicyClient2 struct { + iface ProjectNetworkPolicyInterface + controller ProjectNetworkPolicyController +} + +func (n *projectNetworkPolicyClient2) Interface() ProjectNetworkPolicyInterface { + return n.iface +} + +func (n *projectNetworkPolicyClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *projectNetworkPolicyClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *projectNetworkPolicyClient2) Create(obj *ProjectNetworkPolicy) (*ProjectNetworkPolicy, error) { + return n.iface.Create(obj) +} + +func (n *projectNetworkPolicyClient2) Get(namespace, name string, opts metav1.GetOptions) (*ProjectNetworkPolicy, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *projectNetworkPolicyClient2) Update(obj *ProjectNetworkPolicy) (*ProjectNetworkPolicy, error) { + return n.iface.Update(obj) +} + +func (n *projectNetworkPolicyClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *projectNetworkPolicyClient2) List(namespace string, opts metav1.ListOptions) (*ProjectNetworkPolicyList, error) { + return n.iface.List(opts) +} + +func (n *projectNetworkPolicyClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *projectNetworkPolicyClientCache) Get(namespace, name string) (*ProjectNetworkPolicy, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *projectNetworkPolicyClientCache) List(namespace string, selector labels.Selector) ([]*ProjectNetworkPolicy, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *projectNetworkPolicyClient2) Cache() ProjectNetworkPolicyClientCache { + n.loadController() + return &projectNetworkPolicyClientCache{ + client: n, + } +} + +func (n *projectNetworkPolicyClient2) OnCreate(ctx context.Context, name string, sync ProjectNetworkPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectNetworkPolicyLifecycleDelegate{create: sync}) +} + +func (n *projectNetworkPolicyClient2) OnChange(ctx context.Context, name string, sync ProjectNetworkPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectNetworkPolicyLifecycleDelegate{update: sync}) +} + +func (n *projectNetworkPolicyClient2) OnRemove(ctx context.Context, name string, sync ProjectNetworkPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectNetworkPolicyLifecycleDelegate{remove: sync}) +} + +func (n *projectNetworkPolicyClientCache) Index(name string, indexer ProjectNetworkPolicyIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ProjectNetworkPolicy); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *projectNetworkPolicyClientCache) GetIndexed(name, key string) ([]*ProjectNetworkPolicy, error) { + var result []*ProjectNetworkPolicy + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ProjectNetworkPolicy); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *projectNetworkPolicyClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type projectNetworkPolicyLifecycleDelegate struct { + create ProjectNetworkPolicyChangeHandlerFunc + update ProjectNetworkPolicyChangeHandlerFunc + remove ProjectNetworkPolicyChangeHandlerFunc +} + +func (n *projectNetworkPolicyLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *projectNetworkPolicyLifecycleDelegate) Create(obj *ProjectNetworkPolicy) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *projectNetworkPolicyLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *projectNetworkPolicyLifecycleDelegate) Remove(obj *ProjectNetworkPolicy) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *projectNetworkPolicyLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *projectNetworkPolicyLifecycleDelegate) Updated(obj *ProjectNetworkPolicy) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_controller.go b/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_controller.go index 5cccf0f2..d116da58 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_controller.go @@ -37,6 +37,8 @@ type ProjectRoleTemplateBindingList struct { type ProjectRoleTemplateBindingHandlerFunc func(key string, obj *ProjectRoleTemplateBinding) (runtime.Object, error) +type ProjectRoleTemplateBindingChangeHandlerFunc func(obj *ProjectRoleTemplateBinding) (runtime.Object, error) + type ProjectRoleTemplateBindingLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectRoleTemplateBinding, err error) Get(namespace, name string) (*ProjectRoleTemplateBinding, error) @@ -248,3 +250,182 @@ func (s *projectRoleTemplateBindingClient) AddClusterScopedLifecycle(ctx context sync := NewProjectRoleTemplateBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ProjectRoleTemplateBindingIndexer func(obj *ProjectRoleTemplateBinding) ([]string, error) + +type ProjectRoleTemplateBindingClientCache interface { + Get(namespace, name string) (*ProjectRoleTemplateBinding, error) + List(namespace string, selector labels.Selector) ([]*ProjectRoleTemplateBinding, error) + + Index(name string, indexer ProjectRoleTemplateBindingIndexer) + GetIndexed(name, key string) ([]*ProjectRoleTemplateBinding, error) +} + +type ProjectRoleTemplateBindingClient interface { + Create(*ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error) + Get(namespace, name string, opts metav1.GetOptions) (*ProjectRoleTemplateBinding, error) + Update(*ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ProjectRoleTemplateBindingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ProjectRoleTemplateBindingClientCache + + OnCreate(ctx context.Context, name string, sync ProjectRoleTemplateBindingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ProjectRoleTemplateBindingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ProjectRoleTemplateBindingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ProjectRoleTemplateBindingInterface +} + +type projectRoleTemplateBindingClientCache struct { + client *projectRoleTemplateBindingClient2 +} + +type projectRoleTemplateBindingClient2 struct { + iface ProjectRoleTemplateBindingInterface + controller ProjectRoleTemplateBindingController +} + +func (n *projectRoleTemplateBindingClient2) Interface() ProjectRoleTemplateBindingInterface { + return n.iface +} + +func (n *projectRoleTemplateBindingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *projectRoleTemplateBindingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *projectRoleTemplateBindingClient2) Create(obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error) { + return n.iface.Create(obj) +} + +func (n *projectRoleTemplateBindingClient2) Get(namespace, name string, opts metav1.GetOptions) (*ProjectRoleTemplateBinding, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *projectRoleTemplateBindingClient2) Update(obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error) { + return n.iface.Update(obj) +} + +func (n *projectRoleTemplateBindingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *projectRoleTemplateBindingClient2) List(namespace string, opts metav1.ListOptions) (*ProjectRoleTemplateBindingList, error) { + return n.iface.List(opts) +} + +func (n *projectRoleTemplateBindingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *projectRoleTemplateBindingClientCache) Get(namespace, name string) (*ProjectRoleTemplateBinding, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *projectRoleTemplateBindingClientCache) List(namespace string, selector labels.Selector) ([]*ProjectRoleTemplateBinding, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *projectRoleTemplateBindingClient2) Cache() ProjectRoleTemplateBindingClientCache { + n.loadController() + return &projectRoleTemplateBindingClientCache{ + client: n, + } +} + +func (n *projectRoleTemplateBindingClient2) OnCreate(ctx context.Context, name string, sync ProjectRoleTemplateBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectRoleTemplateBindingLifecycleDelegate{create: sync}) +} + +func (n *projectRoleTemplateBindingClient2) OnChange(ctx context.Context, name string, sync ProjectRoleTemplateBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectRoleTemplateBindingLifecycleDelegate{update: sync}) +} + +func (n *projectRoleTemplateBindingClient2) OnRemove(ctx context.Context, name string, sync ProjectRoleTemplateBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &projectRoleTemplateBindingLifecycleDelegate{remove: sync}) +} + +func (n *projectRoleTemplateBindingClientCache) Index(name string, indexer ProjectRoleTemplateBindingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ProjectRoleTemplateBinding); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *projectRoleTemplateBindingClientCache) GetIndexed(name, key string) ([]*ProjectRoleTemplateBinding, error) { + var result []*ProjectRoleTemplateBinding + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ProjectRoleTemplateBinding); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *projectRoleTemplateBindingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type projectRoleTemplateBindingLifecycleDelegate struct { + create ProjectRoleTemplateBindingChangeHandlerFunc + update ProjectRoleTemplateBindingChangeHandlerFunc + remove ProjectRoleTemplateBindingChangeHandlerFunc +} + +func (n *projectRoleTemplateBindingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *projectRoleTemplateBindingLifecycleDelegate) Create(obj *ProjectRoleTemplateBinding) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *projectRoleTemplateBindingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *projectRoleTemplateBindingLifecycleDelegate) Remove(obj *ProjectRoleTemplateBinding) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *projectRoleTemplateBindingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *projectRoleTemplateBindingLifecycleDelegate) Updated(obj *ProjectRoleTemplateBinding) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_role_template_controller.go b/apis/management.cattle.io/v3/zz_generated_role_template_controller.go index 13d7caec..1500f9a3 100644 --- a/apis/management.cattle.io/v3/zz_generated_role_template_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_role_template_controller.go @@ -36,6 +36,8 @@ type RoleTemplateList struct { type RoleTemplateHandlerFunc func(key string, obj *RoleTemplate) (runtime.Object, error) +type RoleTemplateChangeHandlerFunc func(obj *RoleTemplate) (runtime.Object, error) + type RoleTemplateLister interface { List(namespace string, selector labels.Selector) (ret []*RoleTemplate, err error) Get(namespace, name string) (*RoleTemplate, error) @@ -247,3 +249,182 @@ func (s *roleTemplateClient) AddClusterScopedLifecycle(ctx context.Context, name sync := NewRoleTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type RoleTemplateIndexer func(obj *RoleTemplate) ([]string, error) + +type RoleTemplateClientCache interface { + Get(namespace, name string) (*RoleTemplate, error) + List(namespace string, selector labels.Selector) ([]*RoleTemplate, error) + + Index(name string, indexer RoleTemplateIndexer) + GetIndexed(name, key string) ([]*RoleTemplate, error) +} + +type RoleTemplateClient interface { + Create(*RoleTemplate) (*RoleTemplate, error) + Get(namespace, name string, opts metav1.GetOptions) (*RoleTemplate, error) + Update(*RoleTemplate) (*RoleTemplate, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*RoleTemplateList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() RoleTemplateClientCache + + OnCreate(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() RoleTemplateInterface +} + +type roleTemplateClientCache struct { + client *roleTemplateClient2 +} + +type roleTemplateClient2 struct { + iface RoleTemplateInterface + controller RoleTemplateController +} + +func (n *roleTemplateClient2) Interface() RoleTemplateInterface { + return n.iface +} + +func (n *roleTemplateClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *roleTemplateClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *roleTemplateClient2) Create(obj *RoleTemplate) (*RoleTemplate, error) { + return n.iface.Create(obj) +} + +func (n *roleTemplateClient2) Get(namespace, name string, opts metav1.GetOptions) (*RoleTemplate, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *roleTemplateClient2) Update(obj *RoleTemplate) (*RoleTemplate, error) { + return n.iface.Update(obj) +} + +func (n *roleTemplateClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *roleTemplateClient2) List(namespace string, opts metav1.ListOptions) (*RoleTemplateList, error) { + return n.iface.List(opts) +} + +func (n *roleTemplateClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *roleTemplateClientCache) Get(namespace, name string) (*RoleTemplate, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *roleTemplateClientCache) List(namespace string, selector labels.Selector) ([]*RoleTemplate, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *roleTemplateClient2) Cache() RoleTemplateClientCache { + n.loadController() + return &roleTemplateClientCache{ + client: n, + } +} + +func (n *roleTemplateClient2) OnCreate(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleTemplateLifecycleDelegate{create: sync}) +} + +func (n *roleTemplateClient2) OnChange(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleTemplateLifecycleDelegate{update: sync}) +} + +func (n *roleTemplateClient2) OnRemove(ctx context.Context, name string, sync RoleTemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleTemplateLifecycleDelegate{remove: sync}) +} + +func (n *roleTemplateClientCache) Index(name string, indexer RoleTemplateIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*RoleTemplate); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *roleTemplateClientCache) GetIndexed(name, key string) ([]*RoleTemplate, error) { + var result []*RoleTemplate + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*RoleTemplate); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *roleTemplateClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type roleTemplateLifecycleDelegate struct { + create RoleTemplateChangeHandlerFunc + update RoleTemplateChangeHandlerFunc + remove RoleTemplateChangeHandlerFunc +} + +func (n *roleTemplateLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *roleTemplateLifecycleDelegate) Create(obj *RoleTemplate) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *roleTemplateLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *roleTemplateLifecycleDelegate) Remove(obj *RoleTemplate) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *roleTemplateLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *roleTemplateLifecycleDelegate) Updated(obj *RoleTemplate) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_setting_controller.go b/apis/management.cattle.io/v3/zz_generated_setting_controller.go index e6845e33..a41dd7d3 100644 --- a/apis/management.cattle.io/v3/zz_generated_setting_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_setting_controller.go @@ -36,6 +36,8 @@ type SettingList struct { type SettingHandlerFunc func(key string, obj *Setting) (runtime.Object, error) +type SettingChangeHandlerFunc func(obj *Setting) (runtime.Object, error) + type SettingLister interface { List(namespace string, selector labels.Selector) (ret []*Setting, err error) Get(namespace, name string) (*Setting, error) @@ -247,3 +249,182 @@ func (s *settingClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewSettingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SettingIndexer func(obj *Setting) ([]string, error) + +type SettingClientCache interface { + Get(namespace, name string) (*Setting, error) + List(namespace string, selector labels.Selector) ([]*Setting, error) + + Index(name string, indexer SettingIndexer) + GetIndexed(name, key string) ([]*Setting, error) +} + +type SettingClient interface { + Create(*Setting) (*Setting, error) + Get(namespace, name string, opts metav1.GetOptions) (*Setting, error) + Update(*Setting) (*Setting, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SettingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SettingClientCache + + OnCreate(ctx context.Context, name string, sync SettingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SettingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SettingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SettingInterface +} + +type settingClientCache struct { + client *settingClient2 +} + +type settingClient2 struct { + iface SettingInterface + controller SettingController +} + +func (n *settingClient2) Interface() SettingInterface { + return n.iface +} + +func (n *settingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *settingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *settingClient2) Create(obj *Setting) (*Setting, error) { + return n.iface.Create(obj) +} + +func (n *settingClient2) Get(namespace, name string, opts metav1.GetOptions) (*Setting, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *settingClient2) Update(obj *Setting) (*Setting, error) { + return n.iface.Update(obj) +} + +func (n *settingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *settingClient2) List(namespace string, opts metav1.ListOptions) (*SettingList, error) { + return n.iface.List(opts) +} + +func (n *settingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *settingClientCache) Get(namespace, name string) (*Setting, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *settingClientCache) List(namespace string, selector labels.Selector) ([]*Setting, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *settingClient2) Cache() SettingClientCache { + n.loadController() + return &settingClientCache{ + client: n, + } +} + +func (n *settingClient2) OnCreate(ctx context.Context, name string, sync SettingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &settingLifecycleDelegate{create: sync}) +} + +func (n *settingClient2) OnChange(ctx context.Context, name string, sync SettingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &settingLifecycleDelegate{update: sync}) +} + +func (n *settingClient2) OnRemove(ctx context.Context, name string, sync SettingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &settingLifecycleDelegate{remove: sync}) +} + +func (n *settingClientCache) Index(name string, indexer SettingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Setting); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *settingClientCache) GetIndexed(name, key string) ([]*Setting, error) { + var result []*Setting + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Setting); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *settingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type settingLifecycleDelegate struct { + create SettingChangeHandlerFunc + update SettingChangeHandlerFunc + remove SettingChangeHandlerFunc +} + +func (n *settingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *settingLifecycleDelegate) Create(obj *Setting) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *settingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *settingLifecycleDelegate) Remove(obj *Setting) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *settingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *settingLifecycleDelegate) Updated(obj *Setting) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_template_content_controller.go b/apis/management.cattle.io/v3/zz_generated_template_content_controller.go index 205d81b2..5efd09ee 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_content_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_template_content_controller.go @@ -36,6 +36,8 @@ type TemplateContentList struct { type TemplateContentHandlerFunc func(key string, obj *TemplateContent) (runtime.Object, error) +type TemplateContentChangeHandlerFunc func(obj *TemplateContent) (runtime.Object, error) + type TemplateContentLister interface { List(namespace string, selector labels.Selector) (ret []*TemplateContent, err error) Get(namespace, name string) (*TemplateContent, error) @@ -247,3 +249,182 @@ func (s *templateContentClient) AddClusterScopedLifecycle(ctx context.Context, n sync := NewTemplateContentLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type TemplateContentIndexer func(obj *TemplateContent) ([]string, error) + +type TemplateContentClientCache interface { + Get(namespace, name string) (*TemplateContent, error) + List(namespace string, selector labels.Selector) ([]*TemplateContent, error) + + Index(name string, indexer TemplateContentIndexer) + GetIndexed(name, key string) ([]*TemplateContent, error) +} + +type TemplateContentClient interface { + Create(*TemplateContent) (*TemplateContent, error) + Get(namespace, name string, opts metav1.GetOptions) (*TemplateContent, error) + Update(*TemplateContent) (*TemplateContent, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*TemplateContentList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() TemplateContentClientCache + + OnCreate(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() TemplateContentInterface +} + +type templateContentClientCache struct { + client *templateContentClient2 +} + +type templateContentClient2 struct { + iface TemplateContentInterface + controller TemplateContentController +} + +func (n *templateContentClient2) Interface() TemplateContentInterface { + return n.iface +} + +func (n *templateContentClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *templateContentClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *templateContentClient2) Create(obj *TemplateContent) (*TemplateContent, error) { + return n.iface.Create(obj) +} + +func (n *templateContentClient2) Get(namespace, name string, opts metav1.GetOptions) (*TemplateContent, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *templateContentClient2) Update(obj *TemplateContent) (*TemplateContent, error) { + return n.iface.Update(obj) +} + +func (n *templateContentClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *templateContentClient2) List(namespace string, opts metav1.ListOptions) (*TemplateContentList, error) { + return n.iface.List(opts) +} + +func (n *templateContentClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *templateContentClientCache) Get(namespace, name string) (*TemplateContent, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *templateContentClientCache) List(namespace string, selector labels.Selector) ([]*TemplateContent, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *templateContentClient2) Cache() TemplateContentClientCache { + n.loadController() + return &templateContentClientCache{ + client: n, + } +} + +func (n *templateContentClient2) OnCreate(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateContentLifecycleDelegate{create: sync}) +} + +func (n *templateContentClient2) OnChange(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateContentLifecycleDelegate{update: sync}) +} + +func (n *templateContentClient2) OnRemove(ctx context.Context, name string, sync TemplateContentChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateContentLifecycleDelegate{remove: sync}) +} + +func (n *templateContentClientCache) Index(name string, indexer TemplateContentIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*TemplateContent); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *templateContentClientCache) GetIndexed(name, key string) ([]*TemplateContent, error) { + var result []*TemplateContent + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*TemplateContent); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *templateContentClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type templateContentLifecycleDelegate struct { + create TemplateContentChangeHandlerFunc + update TemplateContentChangeHandlerFunc + remove TemplateContentChangeHandlerFunc +} + +func (n *templateContentLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *templateContentLifecycleDelegate) Create(obj *TemplateContent) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *templateContentLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *templateContentLifecycleDelegate) Remove(obj *TemplateContent) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *templateContentLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *templateContentLifecycleDelegate) Updated(obj *TemplateContent) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_template_controller.go b/apis/management.cattle.io/v3/zz_generated_template_controller.go index e62f4e85..4dd708a6 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_template_controller.go @@ -36,6 +36,8 @@ type TemplateList struct { type TemplateHandlerFunc func(key string, obj *Template) (runtime.Object, error) +type TemplateChangeHandlerFunc func(obj *Template) (runtime.Object, error) + type TemplateLister interface { List(namespace string, selector labels.Selector) (ret []*Template, err error) Get(namespace, name string) (*Template, error) @@ -247,3 +249,182 @@ func (s *templateClient) AddClusterScopedLifecycle(ctx context.Context, name, cl sync := NewTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type TemplateIndexer func(obj *Template) ([]string, error) + +type TemplateClientCache interface { + Get(namespace, name string) (*Template, error) + List(namespace string, selector labels.Selector) ([]*Template, error) + + Index(name string, indexer TemplateIndexer) + GetIndexed(name, key string) ([]*Template, error) +} + +type TemplateClient interface { + Create(*Template) (*Template, error) + Get(namespace, name string, opts metav1.GetOptions) (*Template, error) + Update(*Template) (*Template, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*TemplateList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() TemplateClientCache + + OnCreate(ctx context.Context, name string, sync TemplateChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync TemplateChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync TemplateChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() TemplateInterface +} + +type templateClientCache struct { + client *templateClient2 +} + +type templateClient2 struct { + iface TemplateInterface + controller TemplateController +} + +func (n *templateClient2) Interface() TemplateInterface { + return n.iface +} + +func (n *templateClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *templateClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *templateClient2) Create(obj *Template) (*Template, error) { + return n.iface.Create(obj) +} + +func (n *templateClient2) Get(namespace, name string, opts metav1.GetOptions) (*Template, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *templateClient2) Update(obj *Template) (*Template, error) { + return n.iface.Update(obj) +} + +func (n *templateClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *templateClient2) List(namespace string, opts metav1.ListOptions) (*TemplateList, error) { + return n.iface.List(opts) +} + +func (n *templateClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *templateClientCache) Get(namespace, name string) (*Template, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *templateClientCache) List(namespace string, selector labels.Selector) ([]*Template, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *templateClient2) Cache() TemplateClientCache { + n.loadController() + return &templateClientCache{ + client: n, + } +} + +func (n *templateClient2) OnCreate(ctx context.Context, name string, sync TemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateLifecycleDelegate{create: sync}) +} + +func (n *templateClient2) OnChange(ctx context.Context, name string, sync TemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateLifecycleDelegate{update: sync}) +} + +func (n *templateClient2) OnRemove(ctx context.Context, name string, sync TemplateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateLifecycleDelegate{remove: sync}) +} + +func (n *templateClientCache) Index(name string, indexer TemplateIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Template); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *templateClientCache) GetIndexed(name, key string) ([]*Template, error) { + var result []*Template + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Template); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *templateClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type templateLifecycleDelegate struct { + create TemplateChangeHandlerFunc + update TemplateChangeHandlerFunc + remove TemplateChangeHandlerFunc +} + +func (n *templateLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *templateLifecycleDelegate) Create(obj *Template) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *templateLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *templateLifecycleDelegate) Remove(obj *Template) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *templateLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *templateLifecycleDelegate) Updated(obj *Template) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_template_version_controller.go b/apis/management.cattle.io/v3/zz_generated_template_version_controller.go index ffc3c876..e08dafc5 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_version_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_template_version_controller.go @@ -36,6 +36,8 @@ type TemplateVersionList struct { type TemplateVersionHandlerFunc func(key string, obj *TemplateVersion) (runtime.Object, error) +type TemplateVersionChangeHandlerFunc func(obj *TemplateVersion) (runtime.Object, error) + type TemplateVersionLister interface { List(namespace string, selector labels.Selector) (ret []*TemplateVersion, err error) Get(namespace, name string) (*TemplateVersion, error) @@ -247,3 +249,182 @@ func (s *templateVersionClient) AddClusterScopedLifecycle(ctx context.Context, n sync := NewTemplateVersionLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type TemplateVersionIndexer func(obj *TemplateVersion) ([]string, error) + +type TemplateVersionClientCache interface { + Get(namespace, name string) (*TemplateVersion, error) + List(namespace string, selector labels.Selector) ([]*TemplateVersion, error) + + Index(name string, indexer TemplateVersionIndexer) + GetIndexed(name, key string) ([]*TemplateVersion, error) +} + +type TemplateVersionClient interface { + Create(*TemplateVersion) (*TemplateVersion, error) + Get(namespace, name string, opts metav1.GetOptions) (*TemplateVersion, error) + Update(*TemplateVersion) (*TemplateVersion, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*TemplateVersionList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() TemplateVersionClientCache + + OnCreate(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() TemplateVersionInterface +} + +type templateVersionClientCache struct { + client *templateVersionClient2 +} + +type templateVersionClient2 struct { + iface TemplateVersionInterface + controller TemplateVersionController +} + +func (n *templateVersionClient2) Interface() TemplateVersionInterface { + return n.iface +} + +func (n *templateVersionClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *templateVersionClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *templateVersionClient2) Create(obj *TemplateVersion) (*TemplateVersion, error) { + return n.iface.Create(obj) +} + +func (n *templateVersionClient2) Get(namespace, name string, opts metav1.GetOptions) (*TemplateVersion, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *templateVersionClient2) Update(obj *TemplateVersion) (*TemplateVersion, error) { + return n.iface.Update(obj) +} + +func (n *templateVersionClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *templateVersionClient2) List(namespace string, opts metav1.ListOptions) (*TemplateVersionList, error) { + return n.iface.List(opts) +} + +func (n *templateVersionClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *templateVersionClientCache) Get(namespace, name string) (*TemplateVersion, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *templateVersionClientCache) List(namespace string, selector labels.Selector) ([]*TemplateVersion, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *templateVersionClient2) Cache() TemplateVersionClientCache { + n.loadController() + return &templateVersionClientCache{ + client: n, + } +} + +func (n *templateVersionClient2) OnCreate(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateVersionLifecycleDelegate{create: sync}) +} + +func (n *templateVersionClient2) OnChange(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateVersionLifecycleDelegate{update: sync}) +} + +func (n *templateVersionClient2) OnRemove(ctx context.Context, name string, sync TemplateVersionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &templateVersionLifecycleDelegate{remove: sync}) +} + +func (n *templateVersionClientCache) Index(name string, indexer TemplateVersionIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*TemplateVersion); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *templateVersionClientCache) GetIndexed(name, key string) ([]*TemplateVersion, error) { + var result []*TemplateVersion + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*TemplateVersion); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *templateVersionClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type templateVersionLifecycleDelegate struct { + create TemplateVersionChangeHandlerFunc + update TemplateVersionChangeHandlerFunc + remove TemplateVersionChangeHandlerFunc +} + +func (n *templateVersionLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *templateVersionLifecycleDelegate) Create(obj *TemplateVersion) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *templateVersionLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *templateVersionLifecycleDelegate) Remove(obj *TemplateVersion) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *templateVersionLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *templateVersionLifecycleDelegate) Updated(obj *TemplateVersion) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_token_controller.go b/apis/management.cattle.io/v3/zz_generated_token_controller.go index 433bb156..72c45c36 100644 --- a/apis/management.cattle.io/v3/zz_generated_token_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_token_controller.go @@ -36,6 +36,8 @@ type TokenList struct { type TokenHandlerFunc func(key string, obj *Token) (runtime.Object, error) +type TokenChangeHandlerFunc func(obj *Token) (runtime.Object, error) + type TokenLister interface { List(namespace string, selector labels.Selector) (ret []*Token, err error) Get(namespace, name string) (*Token, error) @@ -247,3 +249,182 @@ func (s *tokenClient) AddClusterScopedLifecycle(ctx context.Context, name, clust sync := NewTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type TokenIndexer func(obj *Token) ([]string, error) + +type TokenClientCache interface { + Get(namespace, name string) (*Token, error) + List(namespace string, selector labels.Selector) ([]*Token, error) + + Index(name string, indexer TokenIndexer) + GetIndexed(name, key string) ([]*Token, error) +} + +type TokenClient interface { + Create(*Token) (*Token, error) + Get(namespace, name string, opts metav1.GetOptions) (*Token, error) + Update(*Token) (*Token, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*TokenList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() TokenClientCache + + OnCreate(ctx context.Context, name string, sync TokenChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync TokenChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync TokenChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() TokenInterface +} + +type tokenClientCache struct { + client *tokenClient2 +} + +type tokenClient2 struct { + iface TokenInterface + controller TokenController +} + +func (n *tokenClient2) Interface() TokenInterface { + return n.iface +} + +func (n *tokenClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *tokenClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *tokenClient2) Create(obj *Token) (*Token, error) { + return n.iface.Create(obj) +} + +func (n *tokenClient2) Get(namespace, name string, opts metav1.GetOptions) (*Token, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *tokenClient2) Update(obj *Token) (*Token, error) { + return n.iface.Update(obj) +} + +func (n *tokenClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *tokenClient2) List(namespace string, opts metav1.ListOptions) (*TokenList, error) { + return n.iface.List(opts) +} + +func (n *tokenClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *tokenClientCache) Get(namespace, name string) (*Token, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *tokenClientCache) List(namespace string, selector labels.Selector) ([]*Token, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *tokenClient2) Cache() TokenClientCache { + n.loadController() + return &tokenClientCache{ + client: n, + } +} + +func (n *tokenClient2) OnCreate(ctx context.Context, name string, sync TokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &tokenLifecycleDelegate{create: sync}) +} + +func (n *tokenClient2) OnChange(ctx context.Context, name string, sync TokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &tokenLifecycleDelegate{update: sync}) +} + +func (n *tokenClient2) OnRemove(ctx context.Context, name string, sync TokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &tokenLifecycleDelegate{remove: sync}) +} + +func (n *tokenClientCache) Index(name string, indexer TokenIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Token); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *tokenClientCache) GetIndexed(name, key string) ([]*Token, error) { + var result []*Token + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Token); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *tokenClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type tokenLifecycleDelegate struct { + create TokenChangeHandlerFunc + update TokenChangeHandlerFunc + remove TokenChangeHandlerFunc +} + +func (n *tokenLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *tokenLifecycleDelegate) Create(obj *Token) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *tokenLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *tokenLifecycleDelegate) Remove(obj *Token) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *tokenLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *tokenLifecycleDelegate) Updated(obj *Token) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_user_attribute_controller.go b/apis/management.cattle.io/v3/zz_generated_user_attribute_controller.go index 6b3c3e57..68d476f5 100644 --- a/apis/management.cattle.io/v3/zz_generated_user_attribute_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_user_attribute_controller.go @@ -36,6 +36,8 @@ type UserAttributeList struct { type UserAttributeHandlerFunc func(key string, obj *UserAttribute) (runtime.Object, error) +type UserAttributeChangeHandlerFunc func(obj *UserAttribute) (runtime.Object, error) + type UserAttributeLister interface { List(namespace string, selector labels.Selector) (ret []*UserAttribute, err error) Get(namespace, name string) (*UserAttribute, error) @@ -247,3 +249,182 @@ func (s *userAttributeClient) AddClusterScopedLifecycle(ctx context.Context, nam sync := NewUserAttributeLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type UserAttributeIndexer func(obj *UserAttribute) ([]string, error) + +type UserAttributeClientCache interface { + Get(namespace, name string) (*UserAttribute, error) + List(namespace string, selector labels.Selector) ([]*UserAttribute, error) + + Index(name string, indexer UserAttributeIndexer) + GetIndexed(name, key string) ([]*UserAttribute, error) +} + +type UserAttributeClient interface { + Create(*UserAttribute) (*UserAttribute, error) + Get(namespace, name string, opts metav1.GetOptions) (*UserAttribute, error) + Update(*UserAttribute) (*UserAttribute, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*UserAttributeList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() UserAttributeClientCache + + OnCreate(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() UserAttributeInterface +} + +type userAttributeClientCache struct { + client *userAttributeClient2 +} + +type userAttributeClient2 struct { + iface UserAttributeInterface + controller UserAttributeController +} + +func (n *userAttributeClient2) Interface() UserAttributeInterface { + return n.iface +} + +func (n *userAttributeClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *userAttributeClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *userAttributeClient2) Create(obj *UserAttribute) (*UserAttribute, error) { + return n.iface.Create(obj) +} + +func (n *userAttributeClient2) Get(namespace, name string, opts metav1.GetOptions) (*UserAttribute, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *userAttributeClient2) Update(obj *UserAttribute) (*UserAttribute, error) { + return n.iface.Update(obj) +} + +func (n *userAttributeClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *userAttributeClient2) List(namespace string, opts metav1.ListOptions) (*UserAttributeList, error) { + return n.iface.List(opts) +} + +func (n *userAttributeClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *userAttributeClientCache) Get(namespace, name string) (*UserAttribute, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *userAttributeClientCache) List(namespace string, selector labels.Selector) ([]*UserAttribute, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *userAttributeClient2) Cache() UserAttributeClientCache { + n.loadController() + return &userAttributeClientCache{ + client: n, + } +} + +func (n *userAttributeClient2) OnCreate(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &userAttributeLifecycleDelegate{create: sync}) +} + +func (n *userAttributeClient2) OnChange(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &userAttributeLifecycleDelegate{update: sync}) +} + +func (n *userAttributeClient2) OnRemove(ctx context.Context, name string, sync UserAttributeChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &userAttributeLifecycleDelegate{remove: sync}) +} + +func (n *userAttributeClientCache) Index(name string, indexer UserAttributeIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*UserAttribute); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *userAttributeClientCache) GetIndexed(name, key string) ([]*UserAttribute, error) { + var result []*UserAttribute + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*UserAttribute); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *userAttributeClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type userAttributeLifecycleDelegate struct { + create UserAttributeChangeHandlerFunc + update UserAttributeChangeHandlerFunc + remove UserAttributeChangeHandlerFunc +} + +func (n *userAttributeLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *userAttributeLifecycleDelegate) Create(obj *UserAttribute) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *userAttributeLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *userAttributeLifecycleDelegate) Remove(obj *UserAttribute) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *userAttributeLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *userAttributeLifecycleDelegate) Updated(obj *UserAttribute) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3/zz_generated_user_controller.go b/apis/management.cattle.io/v3/zz_generated_user_controller.go index 32b404c0..42cfe13e 100644 --- a/apis/management.cattle.io/v3/zz_generated_user_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_user_controller.go @@ -36,6 +36,8 @@ type UserList struct { type UserHandlerFunc func(key string, obj *User) (runtime.Object, error) +type UserChangeHandlerFunc func(obj *User) (runtime.Object, error) + type UserLister interface { List(namespace string, selector labels.Selector) (ret []*User, err error) Get(namespace, name string) (*User, error) @@ -247,3 +249,182 @@ func (s *userClient) AddClusterScopedLifecycle(ctx context.Context, name, cluste sync := NewUserLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type UserIndexer func(obj *User) ([]string, error) + +type UserClientCache interface { + Get(namespace, name string) (*User, error) + List(namespace string, selector labels.Selector) ([]*User, error) + + Index(name string, indexer UserIndexer) + GetIndexed(name, key string) ([]*User, error) +} + +type UserClient interface { + Create(*User) (*User, error) + Get(namespace, name string, opts metav1.GetOptions) (*User, error) + Update(*User) (*User, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*UserList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() UserClientCache + + OnCreate(ctx context.Context, name string, sync UserChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync UserChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync UserChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() UserInterface +} + +type userClientCache struct { + client *userClient2 +} + +type userClient2 struct { + iface UserInterface + controller UserController +} + +func (n *userClient2) Interface() UserInterface { + return n.iface +} + +func (n *userClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *userClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *userClient2) Create(obj *User) (*User, error) { + return n.iface.Create(obj) +} + +func (n *userClient2) Get(namespace, name string, opts metav1.GetOptions) (*User, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *userClient2) Update(obj *User) (*User, error) { + return n.iface.Update(obj) +} + +func (n *userClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *userClient2) List(namespace string, opts metav1.ListOptions) (*UserList, error) { + return n.iface.List(opts) +} + +func (n *userClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *userClientCache) Get(namespace, name string) (*User, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *userClientCache) List(namespace string, selector labels.Selector) ([]*User, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *userClient2) Cache() UserClientCache { + n.loadController() + return &userClientCache{ + client: n, + } +} + +func (n *userClient2) OnCreate(ctx context.Context, name string, sync UserChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &userLifecycleDelegate{create: sync}) +} + +func (n *userClient2) OnChange(ctx context.Context, name string, sync UserChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &userLifecycleDelegate{update: sync}) +} + +func (n *userClient2) OnRemove(ctx context.Context, name string, sync UserChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &userLifecycleDelegate{remove: sync}) +} + +func (n *userClientCache) Index(name string, indexer UserIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*User); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *userClientCache) GetIndexed(name, key string) ([]*User, error) { + var result []*User + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*User); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *userClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type userLifecycleDelegate struct { + create UserChangeHandlerFunc + update UserChangeHandlerFunc + remove UserChangeHandlerFunc +} + +func (n *userLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *userLifecycleDelegate) Create(obj *User) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *userLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *userLifecycleDelegate) Remove(obj *User) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *userLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *userLifecycleDelegate) Updated(obj *User) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3public/zz_generated_auth_provider_controller.go b/apis/management.cattle.io/v3public/zz_generated_auth_provider_controller.go index 5fd146b2..8675ac44 100644 --- a/apis/management.cattle.io/v3public/zz_generated_auth_provider_controller.go +++ b/apis/management.cattle.io/v3public/zz_generated_auth_provider_controller.go @@ -36,6 +36,8 @@ type AuthProviderList struct { type AuthProviderHandlerFunc func(key string, obj *AuthProvider) (runtime.Object, error) +type AuthProviderChangeHandlerFunc func(obj *AuthProvider) (runtime.Object, error) + type AuthProviderLister interface { List(namespace string, selector labels.Selector) (ret []*AuthProvider, err error) Get(namespace, name string) (*AuthProvider, error) @@ -247,3 +249,182 @@ func (s *authProviderClient) AddClusterScopedLifecycle(ctx context.Context, name sync := NewAuthProviderLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type AuthProviderIndexer func(obj *AuthProvider) ([]string, error) + +type AuthProviderClientCache interface { + Get(namespace, name string) (*AuthProvider, error) + List(namespace string, selector labels.Selector) ([]*AuthProvider, error) + + Index(name string, indexer AuthProviderIndexer) + GetIndexed(name, key string) ([]*AuthProvider, error) +} + +type AuthProviderClient interface { + Create(*AuthProvider) (*AuthProvider, error) + Get(namespace, name string, opts metav1.GetOptions) (*AuthProvider, error) + Update(*AuthProvider) (*AuthProvider, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*AuthProviderList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() AuthProviderClientCache + + OnCreate(ctx context.Context, name string, sync AuthProviderChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync AuthProviderChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync AuthProviderChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() AuthProviderInterface +} + +type authProviderClientCache struct { + client *authProviderClient2 +} + +type authProviderClient2 struct { + iface AuthProviderInterface + controller AuthProviderController +} + +func (n *authProviderClient2) Interface() AuthProviderInterface { + return n.iface +} + +func (n *authProviderClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *authProviderClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *authProviderClient2) Create(obj *AuthProvider) (*AuthProvider, error) { + return n.iface.Create(obj) +} + +func (n *authProviderClient2) Get(namespace, name string, opts metav1.GetOptions) (*AuthProvider, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *authProviderClient2) Update(obj *AuthProvider) (*AuthProvider, error) { + return n.iface.Update(obj) +} + +func (n *authProviderClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *authProviderClient2) List(namespace string, opts metav1.ListOptions) (*AuthProviderList, error) { + return n.iface.List(opts) +} + +func (n *authProviderClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *authProviderClientCache) Get(namespace, name string) (*AuthProvider, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *authProviderClientCache) List(namespace string, selector labels.Selector) ([]*AuthProvider, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *authProviderClient2) Cache() AuthProviderClientCache { + n.loadController() + return &authProviderClientCache{ + client: n, + } +} + +func (n *authProviderClient2) OnCreate(ctx context.Context, name string, sync AuthProviderChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &authProviderLifecycleDelegate{create: sync}) +} + +func (n *authProviderClient2) OnChange(ctx context.Context, name string, sync AuthProviderChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &authProviderLifecycleDelegate{update: sync}) +} + +func (n *authProviderClient2) OnRemove(ctx context.Context, name string, sync AuthProviderChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &authProviderLifecycleDelegate{remove: sync}) +} + +func (n *authProviderClientCache) Index(name string, indexer AuthProviderIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*AuthProvider); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *authProviderClientCache) GetIndexed(name, key string) ([]*AuthProvider, error) { + var result []*AuthProvider + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*AuthProvider); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *authProviderClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type authProviderLifecycleDelegate struct { + create AuthProviderChangeHandlerFunc + update AuthProviderChangeHandlerFunc + remove AuthProviderChangeHandlerFunc +} + +func (n *authProviderLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *authProviderLifecycleDelegate) Create(obj *AuthProvider) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *authProviderLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *authProviderLifecycleDelegate) Remove(obj *AuthProvider) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *authProviderLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *authProviderLifecycleDelegate) Updated(obj *AuthProvider) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/management.cattle.io/v3public/zz_generated_k8s_client.go b/apis/management.cattle.io/v3public/zz_generated_k8s_client.go index dabf1411..b9bd061c 100644 --- a/apis/management.cattle.io/v3public/zz_generated_k8s_client.go +++ b/apis/management.cattle.io/v3public/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -20,6 +23,10 @@ type Interface interface { AuthProvidersGetter } +type Clients struct { + AuthProvider AuthProviderClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -34,13 +41,38 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + AuthProvider: &authProviderClient2{ + iface: iface.AuthProviders(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/networking.k8s.io/v1/zz_generated_k8s_client.go b/apis/networking.k8s.io/v1/zz_generated_k8s_client.go index de98ec6d..7999c165 100644 --- a/apis/networking.k8s.io/v1/zz_generated_k8s_client.go +++ b/apis/networking.k8s.io/v1/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -20,6 +23,10 @@ type Interface interface { NetworkPoliciesGetter } +type Clients struct { + NetworkPolicy NetworkPolicyClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -34,13 +41,38 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + NetworkPolicy: &networkPolicyClient2{ + iface: iface.NetworkPolicies(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/networking.k8s.io/v1/zz_generated_network_policy_controller.go b/apis/networking.k8s.io/v1/zz_generated_network_policy_controller.go index 75129345..f3c3216f 100644 --- a/apis/networking.k8s.io/v1/zz_generated_network_policy_controller.go +++ b/apis/networking.k8s.io/v1/zz_generated_network_policy_controller.go @@ -38,6 +38,8 @@ type NetworkPolicyList struct { type NetworkPolicyHandlerFunc func(key string, obj *v1.NetworkPolicy) (runtime.Object, error) +type NetworkPolicyChangeHandlerFunc func(obj *v1.NetworkPolicy) (runtime.Object, error) + type NetworkPolicyLister interface { List(namespace string, selector labels.Selector) (ret []*v1.NetworkPolicy, err error) Get(namespace, name string) (*v1.NetworkPolicy, error) @@ -249,3 +251,182 @@ func (s *networkPolicyClient) AddClusterScopedLifecycle(ctx context.Context, nam sync := NewNetworkPolicyLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NetworkPolicyIndexer func(obj *v1.NetworkPolicy) ([]string, error) + +type NetworkPolicyClientCache interface { + Get(namespace, name string) (*v1.NetworkPolicy, error) + List(namespace string, selector labels.Selector) ([]*v1.NetworkPolicy, error) + + Index(name string, indexer NetworkPolicyIndexer) + GetIndexed(name, key string) ([]*v1.NetworkPolicy, error) +} + +type NetworkPolicyClient interface { + Create(*v1.NetworkPolicy) (*v1.NetworkPolicy, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.NetworkPolicy, error) + Update(*v1.NetworkPolicy) (*v1.NetworkPolicy, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NetworkPolicyList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NetworkPolicyClientCache + + OnCreate(ctx context.Context, name string, sync NetworkPolicyChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NetworkPolicyChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NetworkPolicyChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NetworkPolicyInterface +} + +type networkPolicyClientCache struct { + client *networkPolicyClient2 +} + +type networkPolicyClient2 struct { + iface NetworkPolicyInterface + controller NetworkPolicyController +} + +func (n *networkPolicyClient2) Interface() NetworkPolicyInterface { + return n.iface +} + +func (n *networkPolicyClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *networkPolicyClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *networkPolicyClient2) Create(obj *v1.NetworkPolicy) (*v1.NetworkPolicy, error) { + return n.iface.Create(obj) +} + +func (n *networkPolicyClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.NetworkPolicy, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *networkPolicyClient2) Update(obj *v1.NetworkPolicy) (*v1.NetworkPolicy, error) { + return n.iface.Update(obj) +} + +func (n *networkPolicyClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *networkPolicyClient2) List(namespace string, opts metav1.ListOptions) (*NetworkPolicyList, error) { + return n.iface.List(opts) +} + +func (n *networkPolicyClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *networkPolicyClientCache) Get(namespace, name string) (*v1.NetworkPolicy, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *networkPolicyClientCache) List(namespace string, selector labels.Selector) ([]*v1.NetworkPolicy, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *networkPolicyClient2) Cache() NetworkPolicyClientCache { + n.loadController() + return &networkPolicyClientCache{ + client: n, + } +} + +func (n *networkPolicyClient2) OnCreate(ctx context.Context, name string, sync NetworkPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &networkPolicyLifecycleDelegate{create: sync}) +} + +func (n *networkPolicyClient2) OnChange(ctx context.Context, name string, sync NetworkPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &networkPolicyLifecycleDelegate{update: sync}) +} + +func (n *networkPolicyClient2) OnRemove(ctx context.Context, name string, sync NetworkPolicyChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &networkPolicyLifecycleDelegate{remove: sync}) +} + +func (n *networkPolicyClientCache) Index(name string, indexer NetworkPolicyIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.NetworkPolicy); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *networkPolicyClientCache) GetIndexed(name, key string) ([]*v1.NetworkPolicy, error) { + var result []*v1.NetworkPolicy + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.NetworkPolicy); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *networkPolicyClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type networkPolicyLifecycleDelegate struct { + create NetworkPolicyChangeHandlerFunc + update NetworkPolicyChangeHandlerFunc + remove NetworkPolicyChangeHandlerFunc +} + +func (n *networkPolicyLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *networkPolicyLifecycleDelegate) Create(obj *v1.NetworkPolicy) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *networkPolicyLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *networkPolicyLifecycleDelegate) Remove(obj *v1.NetworkPolicy) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *networkPolicyLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *networkPolicyLifecycleDelegate) Updated(obj *v1.NetworkPolicy) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_app_controller.go b/apis/project.cattle.io/v3/zz_generated_app_controller.go index 2bed92e4..46578d81 100644 --- a/apis/project.cattle.io/v3/zz_generated_app_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_app_controller.go @@ -37,6 +37,8 @@ type AppList struct { type AppHandlerFunc func(key string, obj *App) (runtime.Object, error) +type AppChangeHandlerFunc func(obj *App) (runtime.Object, error) + type AppLister interface { List(namespace string, selector labels.Selector) (ret []*App, err error) Get(namespace, name string) (*App, error) @@ -248,3 +250,182 @@ func (s *appClient) AddClusterScopedLifecycle(ctx context.Context, name, cluster sync := NewAppLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type AppIndexer func(obj *App) ([]string, error) + +type AppClientCache interface { + Get(namespace, name string) (*App, error) + List(namespace string, selector labels.Selector) ([]*App, error) + + Index(name string, indexer AppIndexer) + GetIndexed(name, key string) ([]*App, error) +} + +type AppClient interface { + Create(*App) (*App, error) + Get(namespace, name string, opts metav1.GetOptions) (*App, error) + Update(*App) (*App, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*AppList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() AppClientCache + + OnCreate(ctx context.Context, name string, sync AppChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync AppChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync AppChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() AppInterface +} + +type appClientCache struct { + client *appClient2 +} + +type appClient2 struct { + iface AppInterface + controller AppController +} + +func (n *appClient2) Interface() AppInterface { + return n.iface +} + +func (n *appClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *appClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *appClient2) Create(obj *App) (*App, error) { + return n.iface.Create(obj) +} + +func (n *appClient2) Get(namespace, name string, opts metav1.GetOptions) (*App, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *appClient2) Update(obj *App) (*App, error) { + return n.iface.Update(obj) +} + +func (n *appClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *appClient2) List(namespace string, opts metav1.ListOptions) (*AppList, error) { + return n.iface.List(opts) +} + +func (n *appClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *appClientCache) Get(namespace, name string) (*App, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *appClientCache) List(namespace string, selector labels.Selector) ([]*App, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *appClient2) Cache() AppClientCache { + n.loadController() + return &appClientCache{ + client: n, + } +} + +func (n *appClient2) OnCreate(ctx context.Context, name string, sync AppChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &appLifecycleDelegate{create: sync}) +} + +func (n *appClient2) OnChange(ctx context.Context, name string, sync AppChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &appLifecycleDelegate{update: sync}) +} + +func (n *appClient2) OnRemove(ctx context.Context, name string, sync AppChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &appLifecycleDelegate{remove: sync}) +} + +func (n *appClientCache) Index(name string, indexer AppIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*App); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *appClientCache) GetIndexed(name, key string) ([]*App, error) { + var result []*App + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*App); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *appClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type appLifecycleDelegate struct { + create AppChangeHandlerFunc + update AppChangeHandlerFunc + remove AppChangeHandlerFunc +} + +func (n *appLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *appLifecycleDelegate) Create(obj *App) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *appLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *appLifecycleDelegate) Remove(obj *App) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *appLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *appLifecycleDelegate) Updated(obj *App) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_app_revision_controller.go b/apis/project.cattle.io/v3/zz_generated_app_revision_controller.go index 6502ba9e..c1259fe9 100644 --- a/apis/project.cattle.io/v3/zz_generated_app_revision_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_app_revision_controller.go @@ -37,6 +37,8 @@ type AppRevisionList struct { type AppRevisionHandlerFunc func(key string, obj *AppRevision) (runtime.Object, error) +type AppRevisionChangeHandlerFunc func(obj *AppRevision) (runtime.Object, error) + type AppRevisionLister interface { List(namespace string, selector labels.Selector) (ret []*AppRevision, err error) Get(namespace, name string) (*AppRevision, error) @@ -248,3 +250,182 @@ func (s *appRevisionClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewAppRevisionLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type AppRevisionIndexer func(obj *AppRevision) ([]string, error) + +type AppRevisionClientCache interface { + Get(namespace, name string) (*AppRevision, error) + List(namespace string, selector labels.Selector) ([]*AppRevision, error) + + Index(name string, indexer AppRevisionIndexer) + GetIndexed(name, key string) ([]*AppRevision, error) +} + +type AppRevisionClient interface { + Create(*AppRevision) (*AppRevision, error) + Get(namespace, name string, opts metav1.GetOptions) (*AppRevision, error) + Update(*AppRevision) (*AppRevision, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*AppRevisionList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() AppRevisionClientCache + + OnCreate(ctx context.Context, name string, sync AppRevisionChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync AppRevisionChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync AppRevisionChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() AppRevisionInterface +} + +type appRevisionClientCache struct { + client *appRevisionClient2 +} + +type appRevisionClient2 struct { + iface AppRevisionInterface + controller AppRevisionController +} + +func (n *appRevisionClient2) Interface() AppRevisionInterface { + return n.iface +} + +func (n *appRevisionClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *appRevisionClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *appRevisionClient2) Create(obj *AppRevision) (*AppRevision, error) { + return n.iface.Create(obj) +} + +func (n *appRevisionClient2) Get(namespace, name string, opts metav1.GetOptions) (*AppRevision, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *appRevisionClient2) Update(obj *AppRevision) (*AppRevision, error) { + return n.iface.Update(obj) +} + +func (n *appRevisionClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *appRevisionClient2) List(namespace string, opts metav1.ListOptions) (*AppRevisionList, error) { + return n.iface.List(opts) +} + +func (n *appRevisionClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *appRevisionClientCache) Get(namespace, name string) (*AppRevision, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *appRevisionClientCache) List(namespace string, selector labels.Selector) ([]*AppRevision, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *appRevisionClient2) Cache() AppRevisionClientCache { + n.loadController() + return &appRevisionClientCache{ + client: n, + } +} + +func (n *appRevisionClient2) OnCreate(ctx context.Context, name string, sync AppRevisionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &appRevisionLifecycleDelegate{create: sync}) +} + +func (n *appRevisionClient2) OnChange(ctx context.Context, name string, sync AppRevisionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &appRevisionLifecycleDelegate{update: sync}) +} + +func (n *appRevisionClient2) OnRemove(ctx context.Context, name string, sync AppRevisionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &appRevisionLifecycleDelegate{remove: sync}) +} + +func (n *appRevisionClientCache) Index(name string, indexer AppRevisionIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*AppRevision); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *appRevisionClientCache) GetIndexed(name, key string) ([]*AppRevision, error) { + var result []*AppRevision + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*AppRevision); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *appRevisionClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type appRevisionLifecycleDelegate struct { + create AppRevisionChangeHandlerFunc + update AppRevisionChangeHandlerFunc + remove AppRevisionChangeHandlerFunc +} + +func (n *appRevisionLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *appRevisionLifecycleDelegate) Create(obj *AppRevision) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *appRevisionLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *appRevisionLifecycleDelegate) Remove(obj *AppRevision) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *appRevisionLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *appRevisionLifecycleDelegate) Updated(obj *AppRevision) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_basic_auth_controller.go b/apis/project.cattle.io/v3/zz_generated_basic_auth_controller.go index 5f6b8fbc..848f56bb 100644 --- a/apis/project.cattle.io/v3/zz_generated_basic_auth_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_basic_auth_controller.go @@ -37,6 +37,8 @@ type BasicAuthList struct { type BasicAuthHandlerFunc func(key string, obj *BasicAuth) (runtime.Object, error) +type BasicAuthChangeHandlerFunc func(obj *BasicAuth) (runtime.Object, error) + type BasicAuthLister interface { List(namespace string, selector labels.Selector) (ret []*BasicAuth, err error) Get(namespace, name string) (*BasicAuth, error) @@ -248,3 +250,182 @@ func (s *basicAuthClient) AddClusterScopedLifecycle(ctx context.Context, name, c sync := NewBasicAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type BasicAuthIndexer func(obj *BasicAuth) ([]string, error) + +type BasicAuthClientCache interface { + Get(namespace, name string) (*BasicAuth, error) + List(namespace string, selector labels.Selector) ([]*BasicAuth, error) + + Index(name string, indexer BasicAuthIndexer) + GetIndexed(name, key string) ([]*BasicAuth, error) +} + +type BasicAuthClient interface { + Create(*BasicAuth) (*BasicAuth, error) + Get(namespace, name string, opts metav1.GetOptions) (*BasicAuth, error) + Update(*BasicAuth) (*BasicAuth, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*BasicAuthList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() BasicAuthClientCache + + OnCreate(ctx context.Context, name string, sync BasicAuthChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync BasicAuthChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync BasicAuthChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() BasicAuthInterface +} + +type basicAuthClientCache struct { + client *basicAuthClient2 +} + +type basicAuthClient2 struct { + iface BasicAuthInterface + controller BasicAuthController +} + +func (n *basicAuthClient2) Interface() BasicAuthInterface { + return n.iface +} + +func (n *basicAuthClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *basicAuthClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *basicAuthClient2) Create(obj *BasicAuth) (*BasicAuth, error) { + return n.iface.Create(obj) +} + +func (n *basicAuthClient2) Get(namespace, name string, opts metav1.GetOptions) (*BasicAuth, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *basicAuthClient2) Update(obj *BasicAuth) (*BasicAuth, error) { + return n.iface.Update(obj) +} + +func (n *basicAuthClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *basicAuthClient2) List(namespace string, opts metav1.ListOptions) (*BasicAuthList, error) { + return n.iface.List(opts) +} + +func (n *basicAuthClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *basicAuthClientCache) Get(namespace, name string) (*BasicAuth, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *basicAuthClientCache) List(namespace string, selector labels.Selector) ([]*BasicAuth, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *basicAuthClient2) Cache() BasicAuthClientCache { + n.loadController() + return &basicAuthClientCache{ + client: n, + } +} + +func (n *basicAuthClient2) OnCreate(ctx context.Context, name string, sync BasicAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &basicAuthLifecycleDelegate{create: sync}) +} + +func (n *basicAuthClient2) OnChange(ctx context.Context, name string, sync BasicAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &basicAuthLifecycleDelegate{update: sync}) +} + +func (n *basicAuthClient2) OnRemove(ctx context.Context, name string, sync BasicAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &basicAuthLifecycleDelegate{remove: sync}) +} + +func (n *basicAuthClientCache) Index(name string, indexer BasicAuthIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*BasicAuth); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *basicAuthClientCache) GetIndexed(name, key string) ([]*BasicAuth, error) { + var result []*BasicAuth + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*BasicAuth); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *basicAuthClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type basicAuthLifecycleDelegate struct { + create BasicAuthChangeHandlerFunc + update BasicAuthChangeHandlerFunc + remove BasicAuthChangeHandlerFunc +} + +func (n *basicAuthLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *basicAuthLifecycleDelegate) Create(obj *BasicAuth) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *basicAuthLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *basicAuthLifecycleDelegate) Remove(obj *BasicAuth) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *basicAuthLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *basicAuthLifecycleDelegate) Updated(obj *BasicAuth) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_certificate_controller.go b/apis/project.cattle.io/v3/zz_generated_certificate_controller.go index 937a59be..c7adf396 100644 --- a/apis/project.cattle.io/v3/zz_generated_certificate_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_certificate_controller.go @@ -37,6 +37,8 @@ type CertificateList struct { type CertificateHandlerFunc func(key string, obj *Certificate) (runtime.Object, error) +type CertificateChangeHandlerFunc func(obj *Certificate) (runtime.Object, error) + type CertificateLister interface { List(namespace string, selector labels.Selector) (ret []*Certificate, err error) Get(namespace, name string) (*Certificate, error) @@ -248,3 +250,182 @@ func (s *certificateClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewCertificateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type CertificateIndexer func(obj *Certificate) ([]string, error) + +type CertificateClientCache interface { + Get(namespace, name string) (*Certificate, error) + List(namespace string, selector labels.Selector) ([]*Certificate, error) + + Index(name string, indexer CertificateIndexer) + GetIndexed(name, key string) ([]*Certificate, error) +} + +type CertificateClient interface { + Create(*Certificate) (*Certificate, error) + Get(namespace, name string, opts metav1.GetOptions) (*Certificate, error) + Update(*Certificate) (*Certificate, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*CertificateList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() CertificateClientCache + + OnCreate(ctx context.Context, name string, sync CertificateChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync CertificateChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync CertificateChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() CertificateInterface +} + +type certificateClientCache struct { + client *certificateClient2 +} + +type certificateClient2 struct { + iface CertificateInterface + controller CertificateController +} + +func (n *certificateClient2) Interface() CertificateInterface { + return n.iface +} + +func (n *certificateClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *certificateClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *certificateClient2) Create(obj *Certificate) (*Certificate, error) { + return n.iface.Create(obj) +} + +func (n *certificateClient2) Get(namespace, name string, opts metav1.GetOptions) (*Certificate, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *certificateClient2) Update(obj *Certificate) (*Certificate, error) { + return n.iface.Update(obj) +} + +func (n *certificateClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *certificateClient2) List(namespace string, opts metav1.ListOptions) (*CertificateList, error) { + return n.iface.List(opts) +} + +func (n *certificateClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *certificateClientCache) Get(namespace, name string) (*Certificate, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *certificateClientCache) List(namespace string, selector labels.Selector) ([]*Certificate, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *certificateClient2) Cache() CertificateClientCache { + n.loadController() + return &certificateClientCache{ + client: n, + } +} + +func (n *certificateClient2) OnCreate(ctx context.Context, name string, sync CertificateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &certificateLifecycleDelegate{create: sync}) +} + +func (n *certificateClient2) OnChange(ctx context.Context, name string, sync CertificateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &certificateLifecycleDelegate{update: sync}) +} + +func (n *certificateClient2) OnRemove(ctx context.Context, name string, sync CertificateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &certificateLifecycleDelegate{remove: sync}) +} + +func (n *certificateClientCache) Index(name string, indexer CertificateIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Certificate); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *certificateClientCache) GetIndexed(name, key string) ([]*Certificate, error) { + var result []*Certificate + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Certificate); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *certificateClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type certificateLifecycleDelegate struct { + create CertificateChangeHandlerFunc + update CertificateChangeHandlerFunc + remove CertificateChangeHandlerFunc +} + +func (n *certificateLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *certificateLifecycleDelegate) Create(obj *Certificate) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *certificateLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *certificateLifecycleDelegate) Remove(obj *Certificate) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *certificateLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *certificateLifecycleDelegate) Updated(obj *Certificate) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_docker_credential_controller.go b/apis/project.cattle.io/v3/zz_generated_docker_credential_controller.go index 7b6d8796..c7f32c2d 100644 --- a/apis/project.cattle.io/v3/zz_generated_docker_credential_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_docker_credential_controller.go @@ -37,6 +37,8 @@ type DockerCredentialList struct { type DockerCredentialHandlerFunc func(key string, obj *DockerCredential) (runtime.Object, error) +type DockerCredentialChangeHandlerFunc func(obj *DockerCredential) (runtime.Object, error) + type DockerCredentialLister interface { List(namespace string, selector labels.Selector) (ret []*DockerCredential, err error) Get(namespace, name string) (*DockerCredential, error) @@ -248,3 +250,182 @@ func (s *dockerCredentialClient) AddClusterScopedLifecycle(ctx context.Context, sync := NewDockerCredentialLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type DockerCredentialIndexer func(obj *DockerCredential) ([]string, error) + +type DockerCredentialClientCache interface { + Get(namespace, name string) (*DockerCredential, error) + List(namespace string, selector labels.Selector) ([]*DockerCredential, error) + + Index(name string, indexer DockerCredentialIndexer) + GetIndexed(name, key string) ([]*DockerCredential, error) +} + +type DockerCredentialClient interface { + Create(*DockerCredential) (*DockerCredential, error) + Get(namespace, name string, opts metav1.GetOptions) (*DockerCredential, error) + Update(*DockerCredential) (*DockerCredential, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*DockerCredentialList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() DockerCredentialClientCache + + OnCreate(ctx context.Context, name string, sync DockerCredentialChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync DockerCredentialChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync DockerCredentialChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() DockerCredentialInterface +} + +type dockerCredentialClientCache struct { + client *dockerCredentialClient2 +} + +type dockerCredentialClient2 struct { + iface DockerCredentialInterface + controller DockerCredentialController +} + +func (n *dockerCredentialClient2) Interface() DockerCredentialInterface { + return n.iface +} + +func (n *dockerCredentialClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *dockerCredentialClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *dockerCredentialClient2) Create(obj *DockerCredential) (*DockerCredential, error) { + return n.iface.Create(obj) +} + +func (n *dockerCredentialClient2) Get(namespace, name string, opts metav1.GetOptions) (*DockerCredential, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *dockerCredentialClient2) Update(obj *DockerCredential) (*DockerCredential, error) { + return n.iface.Update(obj) +} + +func (n *dockerCredentialClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *dockerCredentialClient2) List(namespace string, opts metav1.ListOptions) (*DockerCredentialList, error) { + return n.iface.List(opts) +} + +func (n *dockerCredentialClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *dockerCredentialClientCache) Get(namespace, name string) (*DockerCredential, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *dockerCredentialClientCache) List(namespace string, selector labels.Selector) ([]*DockerCredential, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *dockerCredentialClient2) Cache() DockerCredentialClientCache { + n.loadController() + return &dockerCredentialClientCache{ + client: n, + } +} + +func (n *dockerCredentialClient2) OnCreate(ctx context.Context, name string, sync DockerCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &dockerCredentialLifecycleDelegate{create: sync}) +} + +func (n *dockerCredentialClient2) OnChange(ctx context.Context, name string, sync DockerCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &dockerCredentialLifecycleDelegate{update: sync}) +} + +func (n *dockerCredentialClient2) OnRemove(ctx context.Context, name string, sync DockerCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &dockerCredentialLifecycleDelegate{remove: sync}) +} + +func (n *dockerCredentialClientCache) Index(name string, indexer DockerCredentialIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*DockerCredential); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *dockerCredentialClientCache) GetIndexed(name, key string) ([]*DockerCredential, error) { + var result []*DockerCredential + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*DockerCredential); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *dockerCredentialClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type dockerCredentialLifecycleDelegate struct { + create DockerCredentialChangeHandlerFunc + update DockerCredentialChangeHandlerFunc + remove DockerCredentialChangeHandlerFunc +} + +func (n *dockerCredentialLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *dockerCredentialLifecycleDelegate) Create(obj *DockerCredential) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *dockerCredentialLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *dockerCredentialLifecycleDelegate) Remove(obj *DockerCredential) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *dockerCredentialLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *dockerCredentialLifecycleDelegate) Updated(obj *DockerCredential) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_k8s_client.go b/apis/project.cattle.io/v3/zz_generated_k8s_client.go index 53b53662..1064a979 100644 --- a/apis/project.cattle.io/v3/zz_generated_k8s_client.go +++ b/apis/project.cattle.io/v3/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -39,6 +42,29 @@ type Interface interface { SourceCodeRepositoriesGetter } +type Clients struct { + ServiceAccountToken ServiceAccountTokenClient + DockerCredential DockerCredentialClient + Certificate CertificateClient + BasicAuth BasicAuthClient + SSHAuth SSHAuthClient + NamespacedServiceAccountToken NamespacedServiceAccountTokenClient + NamespacedDockerCredential NamespacedDockerCredentialClient + NamespacedCertificate NamespacedCertificateClient + NamespacedBasicAuth NamespacedBasicAuthClient + NamespacedSSHAuth NamespacedSSHAuthClient + Workload WorkloadClient + App AppClient + AppRevision AppRevisionClient + SourceCodeProvider SourceCodeProviderClient + SourceCodeProviderConfig SourceCodeProviderConfigClient + SourceCodeCredential SourceCodeCredentialClient + Pipeline PipelineClient + PipelineExecution PipelineExecutionClient + PipelineSetting PipelineSettingClient + SourceCodeRepository SourceCodeRepositoryClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -72,13 +98,95 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + ServiceAccountToken: &serviceAccountTokenClient2{ + iface: iface.ServiceAccountTokens(""), + }, + DockerCredential: &dockerCredentialClient2{ + iface: iface.DockerCredentials(""), + }, + Certificate: &certificateClient2{ + iface: iface.Certificates(""), + }, + BasicAuth: &basicAuthClient2{ + iface: iface.BasicAuths(""), + }, + SSHAuth: &sshAuthClient2{ + iface: iface.SSHAuths(""), + }, + NamespacedServiceAccountToken: &namespacedServiceAccountTokenClient2{ + iface: iface.NamespacedServiceAccountTokens(""), + }, + NamespacedDockerCredential: &namespacedDockerCredentialClient2{ + iface: iface.NamespacedDockerCredentials(""), + }, + NamespacedCertificate: &namespacedCertificateClient2{ + iface: iface.NamespacedCertificates(""), + }, + NamespacedBasicAuth: &namespacedBasicAuthClient2{ + iface: iface.NamespacedBasicAuths(""), + }, + NamespacedSSHAuth: &namespacedSshAuthClient2{ + iface: iface.NamespacedSSHAuths(""), + }, + Workload: &workloadClient2{ + iface: iface.Workloads(""), + }, + App: &appClient2{ + iface: iface.Apps(""), + }, + AppRevision: &appRevisionClient2{ + iface: iface.AppRevisions(""), + }, + SourceCodeProvider: &sourceCodeProviderClient2{ + iface: iface.SourceCodeProviders(""), + }, + SourceCodeProviderConfig: &sourceCodeProviderConfigClient2{ + iface: iface.SourceCodeProviderConfigs(""), + }, + SourceCodeCredential: &sourceCodeCredentialClient2{ + iface: iface.SourceCodeCredentials(""), + }, + Pipeline: &pipelineClient2{ + iface: iface.Pipelines(""), + }, + PipelineExecution: &pipelineExecutionClient2{ + iface: iface.PipelineExecutions(""), + }, + PipelineSetting: &pipelineSettingClient2{ + iface: iface.PipelineSettings(""), + }, + SourceCodeRepository: &sourceCodeRepositoryClient2{ + iface: iface.SourceCodeRepositories(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_controller.go b/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_controller.go index 6a6ec4a1..f07f44bd 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_controller.go @@ -37,6 +37,8 @@ type NamespacedBasicAuthList struct { type NamespacedBasicAuthHandlerFunc func(key string, obj *NamespacedBasicAuth) (runtime.Object, error) +type NamespacedBasicAuthChangeHandlerFunc func(obj *NamespacedBasicAuth) (runtime.Object, error) + type NamespacedBasicAuthLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedBasicAuth, err error) Get(namespace, name string) (*NamespacedBasicAuth, error) @@ -248,3 +250,182 @@ func (s *namespacedBasicAuthClient) AddClusterScopedLifecycle(ctx context.Contex sync := NewNamespacedBasicAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NamespacedBasicAuthIndexer func(obj *NamespacedBasicAuth) ([]string, error) + +type NamespacedBasicAuthClientCache interface { + Get(namespace, name string) (*NamespacedBasicAuth, error) + List(namespace string, selector labels.Selector) ([]*NamespacedBasicAuth, error) + + Index(name string, indexer NamespacedBasicAuthIndexer) + GetIndexed(name, key string) ([]*NamespacedBasicAuth, error) +} + +type NamespacedBasicAuthClient interface { + Create(*NamespacedBasicAuth) (*NamespacedBasicAuth, error) + Get(namespace, name string, opts metav1.GetOptions) (*NamespacedBasicAuth, error) + Update(*NamespacedBasicAuth) (*NamespacedBasicAuth, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NamespacedBasicAuthList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NamespacedBasicAuthClientCache + + OnCreate(ctx context.Context, name string, sync NamespacedBasicAuthChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NamespacedBasicAuthChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NamespacedBasicAuthChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NamespacedBasicAuthInterface +} + +type namespacedBasicAuthClientCache struct { + client *namespacedBasicAuthClient2 +} + +type namespacedBasicAuthClient2 struct { + iface NamespacedBasicAuthInterface + controller NamespacedBasicAuthController +} + +func (n *namespacedBasicAuthClient2) Interface() NamespacedBasicAuthInterface { + return n.iface +} + +func (n *namespacedBasicAuthClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *namespacedBasicAuthClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *namespacedBasicAuthClient2) Create(obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error) { + return n.iface.Create(obj) +} + +func (n *namespacedBasicAuthClient2) Get(namespace, name string, opts metav1.GetOptions) (*NamespacedBasicAuth, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *namespacedBasicAuthClient2) Update(obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error) { + return n.iface.Update(obj) +} + +func (n *namespacedBasicAuthClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *namespacedBasicAuthClient2) List(namespace string, opts metav1.ListOptions) (*NamespacedBasicAuthList, error) { + return n.iface.List(opts) +} + +func (n *namespacedBasicAuthClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *namespacedBasicAuthClientCache) Get(namespace, name string) (*NamespacedBasicAuth, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *namespacedBasicAuthClientCache) List(namespace string, selector labels.Selector) ([]*NamespacedBasicAuth, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *namespacedBasicAuthClient2) Cache() NamespacedBasicAuthClientCache { + n.loadController() + return &namespacedBasicAuthClientCache{ + client: n, + } +} + +func (n *namespacedBasicAuthClient2) OnCreate(ctx context.Context, name string, sync NamespacedBasicAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedBasicAuthLifecycleDelegate{create: sync}) +} + +func (n *namespacedBasicAuthClient2) OnChange(ctx context.Context, name string, sync NamespacedBasicAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedBasicAuthLifecycleDelegate{update: sync}) +} + +func (n *namespacedBasicAuthClient2) OnRemove(ctx context.Context, name string, sync NamespacedBasicAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedBasicAuthLifecycleDelegate{remove: sync}) +} + +func (n *namespacedBasicAuthClientCache) Index(name string, indexer NamespacedBasicAuthIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NamespacedBasicAuth); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *namespacedBasicAuthClientCache) GetIndexed(name, key string) ([]*NamespacedBasicAuth, error) { + var result []*NamespacedBasicAuth + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NamespacedBasicAuth); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *namespacedBasicAuthClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type namespacedBasicAuthLifecycleDelegate struct { + create NamespacedBasicAuthChangeHandlerFunc + update NamespacedBasicAuthChangeHandlerFunc + remove NamespacedBasicAuthChangeHandlerFunc +} + +func (n *namespacedBasicAuthLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *namespacedBasicAuthLifecycleDelegate) Create(obj *NamespacedBasicAuth) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *namespacedBasicAuthLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *namespacedBasicAuthLifecycleDelegate) Remove(obj *NamespacedBasicAuth) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *namespacedBasicAuthLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *namespacedBasicAuthLifecycleDelegate) Updated(obj *NamespacedBasicAuth) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_controller.go b/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_controller.go index 0465890a..210ec3ba 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_controller.go @@ -37,6 +37,8 @@ type NamespacedCertificateList struct { type NamespacedCertificateHandlerFunc func(key string, obj *NamespacedCertificate) (runtime.Object, error) +type NamespacedCertificateChangeHandlerFunc func(obj *NamespacedCertificate) (runtime.Object, error) + type NamespacedCertificateLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedCertificate, err error) Get(namespace, name string) (*NamespacedCertificate, error) @@ -248,3 +250,182 @@ func (s *namespacedCertificateClient) AddClusterScopedLifecycle(ctx context.Cont sync := NewNamespacedCertificateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NamespacedCertificateIndexer func(obj *NamespacedCertificate) ([]string, error) + +type NamespacedCertificateClientCache interface { + Get(namespace, name string) (*NamespacedCertificate, error) + List(namespace string, selector labels.Selector) ([]*NamespacedCertificate, error) + + Index(name string, indexer NamespacedCertificateIndexer) + GetIndexed(name, key string) ([]*NamespacedCertificate, error) +} + +type NamespacedCertificateClient interface { + Create(*NamespacedCertificate) (*NamespacedCertificate, error) + Get(namespace, name string, opts metav1.GetOptions) (*NamespacedCertificate, error) + Update(*NamespacedCertificate) (*NamespacedCertificate, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NamespacedCertificateList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NamespacedCertificateClientCache + + OnCreate(ctx context.Context, name string, sync NamespacedCertificateChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NamespacedCertificateChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NamespacedCertificateChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NamespacedCertificateInterface +} + +type namespacedCertificateClientCache struct { + client *namespacedCertificateClient2 +} + +type namespacedCertificateClient2 struct { + iface NamespacedCertificateInterface + controller NamespacedCertificateController +} + +func (n *namespacedCertificateClient2) Interface() NamespacedCertificateInterface { + return n.iface +} + +func (n *namespacedCertificateClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *namespacedCertificateClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *namespacedCertificateClient2) Create(obj *NamespacedCertificate) (*NamespacedCertificate, error) { + return n.iface.Create(obj) +} + +func (n *namespacedCertificateClient2) Get(namespace, name string, opts metav1.GetOptions) (*NamespacedCertificate, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *namespacedCertificateClient2) Update(obj *NamespacedCertificate) (*NamespacedCertificate, error) { + return n.iface.Update(obj) +} + +func (n *namespacedCertificateClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *namespacedCertificateClient2) List(namespace string, opts metav1.ListOptions) (*NamespacedCertificateList, error) { + return n.iface.List(opts) +} + +func (n *namespacedCertificateClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *namespacedCertificateClientCache) Get(namespace, name string) (*NamespacedCertificate, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *namespacedCertificateClientCache) List(namespace string, selector labels.Selector) ([]*NamespacedCertificate, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *namespacedCertificateClient2) Cache() NamespacedCertificateClientCache { + n.loadController() + return &namespacedCertificateClientCache{ + client: n, + } +} + +func (n *namespacedCertificateClient2) OnCreate(ctx context.Context, name string, sync NamespacedCertificateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedCertificateLifecycleDelegate{create: sync}) +} + +func (n *namespacedCertificateClient2) OnChange(ctx context.Context, name string, sync NamespacedCertificateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedCertificateLifecycleDelegate{update: sync}) +} + +func (n *namespacedCertificateClient2) OnRemove(ctx context.Context, name string, sync NamespacedCertificateChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedCertificateLifecycleDelegate{remove: sync}) +} + +func (n *namespacedCertificateClientCache) Index(name string, indexer NamespacedCertificateIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NamespacedCertificate); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *namespacedCertificateClientCache) GetIndexed(name, key string) ([]*NamespacedCertificate, error) { + var result []*NamespacedCertificate + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NamespacedCertificate); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *namespacedCertificateClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type namespacedCertificateLifecycleDelegate struct { + create NamespacedCertificateChangeHandlerFunc + update NamespacedCertificateChangeHandlerFunc + remove NamespacedCertificateChangeHandlerFunc +} + +func (n *namespacedCertificateLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *namespacedCertificateLifecycleDelegate) Create(obj *NamespacedCertificate) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *namespacedCertificateLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *namespacedCertificateLifecycleDelegate) Remove(obj *NamespacedCertificate) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *namespacedCertificateLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *namespacedCertificateLifecycleDelegate) Updated(obj *NamespacedCertificate) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_controller.go b/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_controller.go index 22780824..83be276d 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_controller.go @@ -37,6 +37,8 @@ type NamespacedDockerCredentialList struct { type NamespacedDockerCredentialHandlerFunc func(key string, obj *NamespacedDockerCredential) (runtime.Object, error) +type NamespacedDockerCredentialChangeHandlerFunc func(obj *NamespacedDockerCredential) (runtime.Object, error) + type NamespacedDockerCredentialLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedDockerCredential, err error) Get(namespace, name string) (*NamespacedDockerCredential, error) @@ -248,3 +250,182 @@ func (s *namespacedDockerCredentialClient) AddClusterScopedLifecycle(ctx context sync := NewNamespacedDockerCredentialLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NamespacedDockerCredentialIndexer func(obj *NamespacedDockerCredential) ([]string, error) + +type NamespacedDockerCredentialClientCache interface { + Get(namespace, name string) (*NamespacedDockerCredential, error) + List(namespace string, selector labels.Selector) ([]*NamespacedDockerCredential, error) + + Index(name string, indexer NamespacedDockerCredentialIndexer) + GetIndexed(name, key string) ([]*NamespacedDockerCredential, error) +} + +type NamespacedDockerCredentialClient interface { + Create(*NamespacedDockerCredential) (*NamespacedDockerCredential, error) + Get(namespace, name string, opts metav1.GetOptions) (*NamespacedDockerCredential, error) + Update(*NamespacedDockerCredential) (*NamespacedDockerCredential, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NamespacedDockerCredentialList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NamespacedDockerCredentialClientCache + + OnCreate(ctx context.Context, name string, sync NamespacedDockerCredentialChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NamespacedDockerCredentialChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NamespacedDockerCredentialChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NamespacedDockerCredentialInterface +} + +type namespacedDockerCredentialClientCache struct { + client *namespacedDockerCredentialClient2 +} + +type namespacedDockerCredentialClient2 struct { + iface NamespacedDockerCredentialInterface + controller NamespacedDockerCredentialController +} + +func (n *namespacedDockerCredentialClient2) Interface() NamespacedDockerCredentialInterface { + return n.iface +} + +func (n *namespacedDockerCredentialClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *namespacedDockerCredentialClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *namespacedDockerCredentialClient2) Create(obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error) { + return n.iface.Create(obj) +} + +func (n *namespacedDockerCredentialClient2) Get(namespace, name string, opts metav1.GetOptions) (*NamespacedDockerCredential, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *namespacedDockerCredentialClient2) Update(obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error) { + return n.iface.Update(obj) +} + +func (n *namespacedDockerCredentialClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *namespacedDockerCredentialClient2) List(namespace string, opts metav1.ListOptions) (*NamespacedDockerCredentialList, error) { + return n.iface.List(opts) +} + +func (n *namespacedDockerCredentialClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *namespacedDockerCredentialClientCache) Get(namespace, name string) (*NamespacedDockerCredential, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *namespacedDockerCredentialClientCache) List(namespace string, selector labels.Selector) ([]*NamespacedDockerCredential, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *namespacedDockerCredentialClient2) Cache() NamespacedDockerCredentialClientCache { + n.loadController() + return &namespacedDockerCredentialClientCache{ + client: n, + } +} + +func (n *namespacedDockerCredentialClient2) OnCreate(ctx context.Context, name string, sync NamespacedDockerCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedDockerCredentialLifecycleDelegate{create: sync}) +} + +func (n *namespacedDockerCredentialClient2) OnChange(ctx context.Context, name string, sync NamespacedDockerCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedDockerCredentialLifecycleDelegate{update: sync}) +} + +func (n *namespacedDockerCredentialClient2) OnRemove(ctx context.Context, name string, sync NamespacedDockerCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedDockerCredentialLifecycleDelegate{remove: sync}) +} + +func (n *namespacedDockerCredentialClientCache) Index(name string, indexer NamespacedDockerCredentialIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NamespacedDockerCredential); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *namespacedDockerCredentialClientCache) GetIndexed(name, key string) ([]*NamespacedDockerCredential, error) { + var result []*NamespacedDockerCredential + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NamespacedDockerCredential); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *namespacedDockerCredentialClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type namespacedDockerCredentialLifecycleDelegate struct { + create NamespacedDockerCredentialChangeHandlerFunc + update NamespacedDockerCredentialChangeHandlerFunc + remove NamespacedDockerCredentialChangeHandlerFunc +} + +func (n *namespacedDockerCredentialLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *namespacedDockerCredentialLifecycleDelegate) Create(obj *NamespacedDockerCredential) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *namespacedDockerCredentialLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *namespacedDockerCredentialLifecycleDelegate) Remove(obj *NamespacedDockerCredential) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *namespacedDockerCredentialLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *namespacedDockerCredentialLifecycleDelegate) Updated(obj *NamespacedDockerCredential) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_controller.go b/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_controller.go index 14d67c0e..235a6b7f 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_controller.go @@ -37,6 +37,8 @@ type NamespacedServiceAccountTokenList struct { type NamespacedServiceAccountTokenHandlerFunc func(key string, obj *NamespacedServiceAccountToken) (runtime.Object, error) +type NamespacedServiceAccountTokenChangeHandlerFunc func(obj *NamespacedServiceAccountToken) (runtime.Object, error) + type NamespacedServiceAccountTokenLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedServiceAccountToken, err error) Get(namespace, name string) (*NamespacedServiceAccountToken, error) @@ -248,3 +250,182 @@ func (s *namespacedServiceAccountTokenClient) AddClusterScopedLifecycle(ctx cont sync := NewNamespacedServiceAccountTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NamespacedServiceAccountTokenIndexer func(obj *NamespacedServiceAccountToken) ([]string, error) + +type NamespacedServiceAccountTokenClientCache interface { + Get(namespace, name string) (*NamespacedServiceAccountToken, error) + List(namespace string, selector labels.Selector) ([]*NamespacedServiceAccountToken, error) + + Index(name string, indexer NamespacedServiceAccountTokenIndexer) + GetIndexed(name, key string) ([]*NamespacedServiceAccountToken, error) +} + +type NamespacedServiceAccountTokenClient interface { + Create(*NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) + Get(namespace, name string, opts metav1.GetOptions) (*NamespacedServiceAccountToken, error) + Update(*NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NamespacedServiceAccountTokenList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NamespacedServiceAccountTokenClientCache + + OnCreate(ctx context.Context, name string, sync NamespacedServiceAccountTokenChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NamespacedServiceAccountTokenChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NamespacedServiceAccountTokenChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NamespacedServiceAccountTokenInterface +} + +type namespacedServiceAccountTokenClientCache struct { + client *namespacedServiceAccountTokenClient2 +} + +type namespacedServiceAccountTokenClient2 struct { + iface NamespacedServiceAccountTokenInterface + controller NamespacedServiceAccountTokenController +} + +func (n *namespacedServiceAccountTokenClient2) Interface() NamespacedServiceAccountTokenInterface { + return n.iface +} + +func (n *namespacedServiceAccountTokenClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *namespacedServiceAccountTokenClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *namespacedServiceAccountTokenClient2) Create(obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) { + return n.iface.Create(obj) +} + +func (n *namespacedServiceAccountTokenClient2) Get(namespace, name string, opts metav1.GetOptions) (*NamespacedServiceAccountToken, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *namespacedServiceAccountTokenClient2) Update(obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) { + return n.iface.Update(obj) +} + +func (n *namespacedServiceAccountTokenClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *namespacedServiceAccountTokenClient2) List(namespace string, opts metav1.ListOptions) (*NamespacedServiceAccountTokenList, error) { + return n.iface.List(opts) +} + +func (n *namespacedServiceAccountTokenClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *namespacedServiceAccountTokenClientCache) Get(namespace, name string) (*NamespacedServiceAccountToken, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *namespacedServiceAccountTokenClientCache) List(namespace string, selector labels.Selector) ([]*NamespacedServiceAccountToken, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *namespacedServiceAccountTokenClient2) Cache() NamespacedServiceAccountTokenClientCache { + n.loadController() + return &namespacedServiceAccountTokenClientCache{ + client: n, + } +} + +func (n *namespacedServiceAccountTokenClient2) OnCreate(ctx context.Context, name string, sync NamespacedServiceAccountTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedServiceAccountTokenLifecycleDelegate{create: sync}) +} + +func (n *namespacedServiceAccountTokenClient2) OnChange(ctx context.Context, name string, sync NamespacedServiceAccountTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedServiceAccountTokenLifecycleDelegate{update: sync}) +} + +func (n *namespacedServiceAccountTokenClient2) OnRemove(ctx context.Context, name string, sync NamespacedServiceAccountTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedServiceAccountTokenLifecycleDelegate{remove: sync}) +} + +func (n *namespacedServiceAccountTokenClientCache) Index(name string, indexer NamespacedServiceAccountTokenIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NamespacedServiceAccountToken); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *namespacedServiceAccountTokenClientCache) GetIndexed(name, key string) ([]*NamespacedServiceAccountToken, error) { + var result []*NamespacedServiceAccountToken + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NamespacedServiceAccountToken); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *namespacedServiceAccountTokenClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type namespacedServiceAccountTokenLifecycleDelegate struct { + create NamespacedServiceAccountTokenChangeHandlerFunc + update NamespacedServiceAccountTokenChangeHandlerFunc + remove NamespacedServiceAccountTokenChangeHandlerFunc +} + +func (n *namespacedServiceAccountTokenLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *namespacedServiceAccountTokenLifecycleDelegate) Create(obj *NamespacedServiceAccountToken) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *namespacedServiceAccountTokenLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *namespacedServiceAccountTokenLifecycleDelegate) Remove(obj *NamespacedServiceAccountToken) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *namespacedServiceAccountTokenLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *namespacedServiceAccountTokenLifecycleDelegate) Updated(obj *NamespacedServiceAccountToken) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_controller.go b/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_controller.go index 55019f47..7fcb8ece 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_controller.go @@ -37,6 +37,8 @@ type NamespacedSSHAuthList struct { type NamespacedSSHAuthHandlerFunc func(key string, obj *NamespacedSSHAuth) (runtime.Object, error) +type NamespacedSSHAuthChangeHandlerFunc func(obj *NamespacedSSHAuth) (runtime.Object, error) + type NamespacedSSHAuthLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedSSHAuth, err error) Get(namespace, name string) (*NamespacedSSHAuth, error) @@ -248,3 +250,182 @@ func (s *namespacedSshAuthClient) AddClusterScopedLifecycle(ctx context.Context, sync := NewNamespacedSSHAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type NamespacedSSHAuthIndexer func(obj *NamespacedSSHAuth) ([]string, error) + +type NamespacedSSHAuthClientCache interface { + Get(namespace, name string) (*NamespacedSSHAuth, error) + List(namespace string, selector labels.Selector) ([]*NamespacedSSHAuth, error) + + Index(name string, indexer NamespacedSSHAuthIndexer) + GetIndexed(name, key string) ([]*NamespacedSSHAuth, error) +} + +type NamespacedSSHAuthClient interface { + Create(*NamespacedSSHAuth) (*NamespacedSSHAuth, error) + Get(namespace, name string, opts metav1.GetOptions) (*NamespacedSSHAuth, error) + Update(*NamespacedSSHAuth) (*NamespacedSSHAuth, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*NamespacedSSHAuthList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() NamespacedSSHAuthClientCache + + OnCreate(ctx context.Context, name string, sync NamespacedSSHAuthChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync NamespacedSSHAuthChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync NamespacedSSHAuthChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() NamespacedSSHAuthInterface +} + +type namespacedSshAuthClientCache struct { + client *namespacedSshAuthClient2 +} + +type namespacedSshAuthClient2 struct { + iface NamespacedSSHAuthInterface + controller NamespacedSSHAuthController +} + +func (n *namespacedSshAuthClient2) Interface() NamespacedSSHAuthInterface { + return n.iface +} + +func (n *namespacedSshAuthClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *namespacedSshAuthClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *namespacedSshAuthClient2) Create(obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error) { + return n.iface.Create(obj) +} + +func (n *namespacedSshAuthClient2) Get(namespace, name string, opts metav1.GetOptions) (*NamespacedSSHAuth, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *namespacedSshAuthClient2) Update(obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error) { + return n.iface.Update(obj) +} + +func (n *namespacedSshAuthClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *namespacedSshAuthClient2) List(namespace string, opts metav1.ListOptions) (*NamespacedSSHAuthList, error) { + return n.iface.List(opts) +} + +func (n *namespacedSshAuthClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *namespacedSshAuthClientCache) Get(namespace, name string) (*NamespacedSSHAuth, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *namespacedSshAuthClientCache) List(namespace string, selector labels.Selector) ([]*NamespacedSSHAuth, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *namespacedSshAuthClient2) Cache() NamespacedSSHAuthClientCache { + n.loadController() + return &namespacedSshAuthClientCache{ + client: n, + } +} + +func (n *namespacedSshAuthClient2) OnCreate(ctx context.Context, name string, sync NamespacedSSHAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedSshAuthLifecycleDelegate{create: sync}) +} + +func (n *namespacedSshAuthClient2) OnChange(ctx context.Context, name string, sync NamespacedSSHAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedSshAuthLifecycleDelegate{update: sync}) +} + +func (n *namespacedSshAuthClient2) OnRemove(ctx context.Context, name string, sync NamespacedSSHAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &namespacedSshAuthLifecycleDelegate{remove: sync}) +} + +func (n *namespacedSshAuthClientCache) Index(name string, indexer NamespacedSSHAuthIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*NamespacedSSHAuth); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *namespacedSshAuthClientCache) GetIndexed(name, key string) ([]*NamespacedSSHAuth, error) { + var result []*NamespacedSSHAuth + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*NamespacedSSHAuth); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *namespacedSshAuthClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type namespacedSshAuthLifecycleDelegate struct { + create NamespacedSSHAuthChangeHandlerFunc + update NamespacedSSHAuthChangeHandlerFunc + remove NamespacedSSHAuthChangeHandlerFunc +} + +func (n *namespacedSshAuthLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *namespacedSshAuthLifecycleDelegate) Create(obj *NamespacedSSHAuth) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *namespacedSshAuthLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *namespacedSshAuthLifecycleDelegate) Remove(obj *NamespacedSSHAuth) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *namespacedSshAuthLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *namespacedSshAuthLifecycleDelegate) Updated(obj *NamespacedSSHAuth) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_pipeline_controller.go b/apis/project.cattle.io/v3/zz_generated_pipeline_controller.go index b925fdd4..154a2a13 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_controller.go @@ -37,6 +37,8 @@ type PipelineList struct { type PipelineHandlerFunc func(key string, obj *Pipeline) (runtime.Object, error) +type PipelineChangeHandlerFunc func(obj *Pipeline) (runtime.Object, error) + type PipelineLister interface { List(namespace string, selector labels.Selector) (ret []*Pipeline, err error) Get(namespace, name string) (*Pipeline, error) @@ -248,3 +250,182 @@ func (s *pipelineClient) AddClusterScopedLifecycle(ctx context.Context, name, cl sync := NewPipelineLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PipelineIndexer func(obj *Pipeline) ([]string, error) + +type PipelineClientCache interface { + Get(namespace, name string) (*Pipeline, error) + List(namespace string, selector labels.Selector) ([]*Pipeline, error) + + Index(name string, indexer PipelineIndexer) + GetIndexed(name, key string) ([]*Pipeline, error) +} + +type PipelineClient interface { + Create(*Pipeline) (*Pipeline, error) + Get(namespace, name string, opts metav1.GetOptions) (*Pipeline, error) + Update(*Pipeline) (*Pipeline, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PipelineList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PipelineClientCache + + OnCreate(ctx context.Context, name string, sync PipelineChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PipelineChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PipelineChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PipelineInterface +} + +type pipelineClientCache struct { + client *pipelineClient2 +} + +type pipelineClient2 struct { + iface PipelineInterface + controller PipelineController +} + +func (n *pipelineClient2) Interface() PipelineInterface { + return n.iface +} + +func (n *pipelineClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *pipelineClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *pipelineClient2) Create(obj *Pipeline) (*Pipeline, error) { + return n.iface.Create(obj) +} + +func (n *pipelineClient2) Get(namespace, name string, opts metav1.GetOptions) (*Pipeline, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *pipelineClient2) Update(obj *Pipeline) (*Pipeline, error) { + return n.iface.Update(obj) +} + +func (n *pipelineClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *pipelineClient2) List(namespace string, opts metav1.ListOptions) (*PipelineList, error) { + return n.iface.List(opts) +} + +func (n *pipelineClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *pipelineClientCache) Get(namespace, name string) (*Pipeline, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *pipelineClientCache) List(namespace string, selector labels.Selector) ([]*Pipeline, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *pipelineClient2) Cache() PipelineClientCache { + n.loadController() + return &pipelineClientCache{ + client: n, + } +} + +func (n *pipelineClient2) OnCreate(ctx context.Context, name string, sync PipelineChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineLifecycleDelegate{create: sync}) +} + +func (n *pipelineClient2) OnChange(ctx context.Context, name string, sync PipelineChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineLifecycleDelegate{update: sync}) +} + +func (n *pipelineClient2) OnRemove(ctx context.Context, name string, sync PipelineChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineLifecycleDelegate{remove: sync}) +} + +func (n *pipelineClientCache) Index(name string, indexer PipelineIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Pipeline); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *pipelineClientCache) GetIndexed(name, key string) ([]*Pipeline, error) { + var result []*Pipeline + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Pipeline); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *pipelineClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type pipelineLifecycleDelegate struct { + create PipelineChangeHandlerFunc + update PipelineChangeHandlerFunc + remove PipelineChangeHandlerFunc +} + +func (n *pipelineLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *pipelineLifecycleDelegate) Create(obj *Pipeline) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *pipelineLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *pipelineLifecycleDelegate) Remove(obj *Pipeline) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *pipelineLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *pipelineLifecycleDelegate) Updated(obj *Pipeline) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_pipeline_execution_controller.go b/apis/project.cattle.io/v3/zz_generated_pipeline_execution_controller.go index a51874f4..4f9d3668 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_execution_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_execution_controller.go @@ -37,6 +37,8 @@ type PipelineExecutionList struct { type PipelineExecutionHandlerFunc func(key string, obj *PipelineExecution) (runtime.Object, error) +type PipelineExecutionChangeHandlerFunc func(obj *PipelineExecution) (runtime.Object, error) + type PipelineExecutionLister interface { List(namespace string, selector labels.Selector) (ret []*PipelineExecution, err error) Get(namespace, name string) (*PipelineExecution, error) @@ -248,3 +250,182 @@ func (s *pipelineExecutionClient) AddClusterScopedLifecycle(ctx context.Context, sync := NewPipelineExecutionLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PipelineExecutionIndexer func(obj *PipelineExecution) ([]string, error) + +type PipelineExecutionClientCache interface { + Get(namespace, name string) (*PipelineExecution, error) + List(namespace string, selector labels.Selector) ([]*PipelineExecution, error) + + Index(name string, indexer PipelineExecutionIndexer) + GetIndexed(name, key string) ([]*PipelineExecution, error) +} + +type PipelineExecutionClient interface { + Create(*PipelineExecution) (*PipelineExecution, error) + Get(namespace, name string, opts metav1.GetOptions) (*PipelineExecution, error) + Update(*PipelineExecution) (*PipelineExecution, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PipelineExecutionList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PipelineExecutionClientCache + + OnCreate(ctx context.Context, name string, sync PipelineExecutionChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PipelineExecutionChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PipelineExecutionChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PipelineExecutionInterface +} + +type pipelineExecutionClientCache struct { + client *pipelineExecutionClient2 +} + +type pipelineExecutionClient2 struct { + iface PipelineExecutionInterface + controller PipelineExecutionController +} + +func (n *pipelineExecutionClient2) Interface() PipelineExecutionInterface { + return n.iface +} + +func (n *pipelineExecutionClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *pipelineExecutionClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *pipelineExecutionClient2) Create(obj *PipelineExecution) (*PipelineExecution, error) { + return n.iface.Create(obj) +} + +func (n *pipelineExecutionClient2) Get(namespace, name string, opts metav1.GetOptions) (*PipelineExecution, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *pipelineExecutionClient2) Update(obj *PipelineExecution) (*PipelineExecution, error) { + return n.iface.Update(obj) +} + +func (n *pipelineExecutionClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *pipelineExecutionClient2) List(namespace string, opts metav1.ListOptions) (*PipelineExecutionList, error) { + return n.iface.List(opts) +} + +func (n *pipelineExecutionClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *pipelineExecutionClientCache) Get(namespace, name string) (*PipelineExecution, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *pipelineExecutionClientCache) List(namespace string, selector labels.Selector) ([]*PipelineExecution, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *pipelineExecutionClient2) Cache() PipelineExecutionClientCache { + n.loadController() + return &pipelineExecutionClientCache{ + client: n, + } +} + +func (n *pipelineExecutionClient2) OnCreate(ctx context.Context, name string, sync PipelineExecutionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineExecutionLifecycleDelegate{create: sync}) +} + +func (n *pipelineExecutionClient2) OnChange(ctx context.Context, name string, sync PipelineExecutionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineExecutionLifecycleDelegate{update: sync}) +} + +func (n *pipelineExecutionClient2) OnRemove(ctx context.Context, name string, sync PipelineExecutionChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineExecutionLifecycleDelegate{remove: sync}) +} + +func (n *pipelineExecutionClientCache) Index(name string, indexer PipelineExecutionIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*PipelineExecution); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *pipelineExecutionClientCache) GetIndexed(name, key string) ([]*PipelineExecution, error) { + var result []*PipelineExecution + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*PipelineExecution); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *pipelineExecutionClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type pipelineExecutionLifecycleDelegate struct { + create PipelineExecutionChangeHandlerFunc + update PipelineExecutionChangeHandlerFunc + remove PipelineExecutionChangeHandlerFunc +} + +func (n *pipelineExecutionLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *pipelineExecutionLifecycleDelegate) Create(obj *PipelineExecution) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *pipelineExecutionLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *pipelineExecutionLifecycleDelegate) Remove(obj *PipelineExecution) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *pipelineExecutionLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *pipelineExecutionLifecycleDelegate) Updated(obj *PipelineExecution) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_pipeline_setting_controller.go b/apis/project.cattle.io/v3/zz_generated_pipeline_setting_controller.go index 48a6174a..c8f3b8db 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_setting_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_setting_controller.go @@ -37,6 +37,8 @@ type PipelineSettingList struct { type PipelineSettingHandlerFunc func(key string, obj *PipelineSetting) (runtime.Object, error) +type PipelineSettingChangeHandlerFunc func(obj *PipelineSetting) (runtime.Object, error) + type PipelineSettingLister interface { List(namespace string, selector labels.Selector) (ret []*PipelineSetting, err error) Get(namespace, name string) (*PipelineSetting, error) @@ -248,3 +250,182 @@ func (s *pipelineSettingClient) AddClusterScopedLifecycle(ctx context.Context, n sync := NewPipelineSettingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type PipelineSettingIndexer func(obj *PipelineSetting) ([]string, error) + +type PipelineSettingClientCache interface { + Get(namespace, name string) (*PipelineSetting, error) + List(namespace string, selector labels.Selector) ([]*PipelineSetting, error) + + Index(name string, indexer PipelineSettingIndexer) + GetIndexed(name, key string) ([]*PipelineSetting, error) +} + +type PipelineSettingClient interface { + Create(*PipelineSetting) (*PipelineSetting, error) + Get(namespace, name string, opts metav1.GetOptions) (*PipelineSetting, error) + Update(*PipelineSetting) (*PipelineSetting, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*PipelineSettingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() PipelineSettingClientCache + + OnCreate(ctx context.Context, name string, sync PipelineSettingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync PipelineSettingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync PipelineSettingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() PipelineSettingInterface +} + +type pipelineSettingClientCache struct { + client *pipelineSettingClient2 +} + +type pipelineSettingClient2 struct { + iface PipelineSettingInterface + controller PipelineSettingController +} + +func (n *pipelineSettingClient2) Interface() PipelineSettingInterface { + return n.iface +} + +func (n *pipelineSettingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *pipelineSettingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *pipelineSettingClient2) Create(obj *PipelineSetting) (*PipelineSetting, error) { + return n.iface.Create(obj) +} + +func (n *pipelineSettingClient2) Get(namespace, name string, opts metav1.GetOptions) (*PipelineSetting, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *pipelineSettingClient2) Update(obj *PipelineSetting) (*PipelineSetting, error) { + return n.iface.Update(obj) +} + +func (n *pipelineSettingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *pipelineSettingClient2) List(namespace string, opts metav1.ListOptions) (*PipelineSettingList, error) { + return n.iface.List(opts) +} + +func (n *pipelineSettingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *pipelineSettingClientCache) Get(namespace, name string) (*PipelineSetting, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *pipelineSettingClientCache) List(namespace string, selector labels.Selector) ([]*PipelineSetting, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *pipelineSettingClient2) Cache() PipelineSettingClientCache { + n.loadController() + return &pipelineSettingClientCache{ + client: n, + } +} + +func (n *pipelineSettingClient2) OnCreate(ctx context.Context, name string, sync PipelineSettingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineSettingLifecycleDelegate{create: sync}) +} + +func (n *pipelineSettingClient2) OnChange(ctx context.Context, name string, sync PipelineSettingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineSettingLifecycleDelegate{update: sync}) +} + +func (n *pipelineSettingClient2) OnRemove(ctx context.Context, name string, sync PipelineSettingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &pipelineSettingLifecycleDelegate{remove: sync}) +} + +func (n *pipelineSettingClientCache) Index(name string, indexer PipelineSettingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*PipelineSetting); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *pipelineSettingClientCache) GetIndexed(name, key string) ([]*PipelineSetting, error) { + var result []*PipelineSetting + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*PipelineSetting); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *pipelineSettingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type pipelineSettingLifecycleDelegate struct { + create PipelineSettingChangeHandlerFunc + update PipelineSettingChangeHandlerFunc + remove PipelineSettingChangeHandlerFunc +} + +func (n *pipelineSettingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *pipelineSettingLifecycleDelegate) Create(obj *PipelineSetting) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *pipelineSettingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *pipelineSettingLifecycleDelegate) Remove(obj *PipelineSetting) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *pipelineSettingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *pipelineSettingLifecycleDelegate) Updated(obj *PipelineSetting) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_service_account_token_controller.go b/apis/project.cattle.io/v3/zz_generated_service_account_token_controller.go index 7fc40695..6d79f8c6 100644 --- a/apis/project.cattle.io/v3/zz_generated_service_account_token_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_service_account_token_controller.go @@ -37,6 +37,8 @@ type ServiceAccountTokenList struct { type ServiceAccountTokenHandlerFunc func(key string, obj *ServiceAccountToken) (runtime.Object, error) +type ServiceAccountTokenChangeHandlerFunc func(obj *ServiceAccountToken) (runtime.Object, error) + type ServiceAccountTokenLister interface { List(namespace string, selector labels.Selector) (ret []*ServiceAccountToken, err error) Get(namespace, name string) (*ServiceAccountToken, error) @@ -248,3 +250,182 @@ func (s *serviceAccountTokenClient) AddClusterScopedLifecycle(ctx context.Contex sync := NewServiceAccountTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ServiceAccountTokenIndexer func(obj *ServiceAccountToken) ([]string, error) + +type ServiceAccountTokenClientCache interface { + Get(namespace, name string) (*ServiceAccountToken, error) + List(namespace string, selector labels.Selector) ([]*ServiceAccountToken, error) + + Index(name string, indexer ServiceAccountTokenIndexer) + GetIndexed(name, key string) ([]*ServiceAccountToken, error) +} + +type ServiceAccountTokenClient interface { + Create(*ServiceAccountToken) (*ServiceAccountToken, error) + Get(namespace, name string, opts metav1.GetOptions) (*ServiceAccountToken, error) + Update(*ServiceAccountToken) (*ServiceAccountToken, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ServiceAccountTokenList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ServiceAccountTokenClientCache + + OnCreate(ctx context.Context, name string, sync ServiceAccountTokenChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ServiceAccountTokenChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ServiceAccountTokenChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ServiceAccountTokenInterface +} + +type serviceAccountTokenClientCache struct { + client *serviceAccountTokenClient2 +} + +type serviceAccountTokenClient2 struct { + iface ServiceAccountTokenInterface + controller ServiceAccountTokenController +} + +func (n *serviceAccountTokenClient2) Interface() ServiceAccountTokenInterface { + return n.iface +} + +func (n *serviceAccountTokenClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *serviceAccountTokenClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *serviceAccountTokenClient2) Create(obj *ServiceAccountToken) (*ServiceAccountToken, error) { + return n.iface.Create(obj) +} + +func (n *serviceAccountTokenClient2) Get(namespace, name string, opts metav1.GetOptions) (*ServiceAccountToken, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *serviceAccountTokenClient2) Update(obj *ServiceAccountToken) (*ServiceAccountToken, error) { + return n.iface.Update(obj) +} + +func (n *serviceAccountTokenClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *serviceAccountTokenClient2) List(namespace string, opts metav1.ListOptions) (*ServiceAccountTokenList, error) { + return n.iface.List(opts) +} + +func (n *serviceAccountTokenClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *serviceAccountTokenClientCache) Get(namespace, name string) (*ServiceAccountToken, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *serviceAccountTokenClientCache) List(namespace string, selector labels.Selector) ([]*ServiceAccountToken, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *serviceAccountTokenClient2) Cache() ServiceAccountTokenClientCache { + n.loadController() + return &serviceAccountTokenClientCache{ + client: n, + } +} + +func (n *serviceAccountTokenClient2) OnCreate(ctx context.Context, name string, sync ServiceAccountTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceAccountTokenLifecycleDelegate{create: sync}) +} + +func (n *serviceAccountTokenClient2) OnChange(ctx context.Context, name string, sync ServiceAccountTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceAccountTokenLifecycleDelegate{update: sync}) +} + +func (n *serviceAccountTokenClient2) OnRemove(ctx context.Context, name string, sync ServiceAccountTokenChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &serviceAccountTokenLifecycleDelegate{remove: sync}) +} + +func (n *serviceAccountTokenClientCache) Index(name string, indexer ServiceAccountTokenIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*ServiceAccountToken); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *serviceAccountTokenClientCache) GetIndexed(name, key string) ([]*ServiceAccountToken, error) { + var result []*ServiceAccountToken + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*ServiceAccountToken); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *serviceAccountTokenClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type serviceAccountTokenLifecycleDelegate struct { + create ServiceAccountTokenChangeHandlerFunc + update ServiceAccountTokenChangeHandlerFunc + remove ServiceAccountTokenChangeHandlerFunc +} + +func (n *serviceAccountTokenLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *serviceAccountTokenLifecycleDelegate) Create(obj *ServiceAccountToken) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *serviceAccountTokenLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *serviceAccountTokenLifecycleDelegate) Remove(obj *ServiceAccountToken) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *serviceAccountTokenLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *serviceAccountTokenLifecycleDelegate) Updated(obj *ServiceAccountToken) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_credential_controller.go b/apis/project.cattle.io/v3/zz_generated_source_code_credential_controller.go index 8b3c68a4..a38fb871 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_credential_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_credential_controller.go @@ -37,6 +37,8 @@ type SourceCodeCredentialList struct { type SourceCodeCredentialHandlerFunc func(key string, obj *SourceCodeCredential) (runtime.Object, error) +type SourceCodeCredentialChangeHandlerFunc func(obj *SourceCodeCredential) (runtime.Object, error) + type SourceCodeCredentialLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeCredential, err error) Get(namespace, name string) (*SourceCodeCredential, error) @@ -248,3 +250,182 @@ func (s *sourceCodeCredentialClient) AddClusterScopedLifecycle(ctx context.Conte sync := NewSourceCodeCredentialLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SourceCodeCredentialIndexer func(obj *SourceCodeCredential) ([]string, error) + +type SourceCodeCredentialClientCache interface { + Get(namespace, name string) (*SourceCodeCredential, error) + List(namespace string, selector labels.Selector) ([]*SourceCodeCredential, error) + + Index(name string, indexer SourceCodeCredentialIndexer) + GetIndexed(name, key string) ([]*SourceCodeCredential, error) +} + +type SourceCodeCredentialClient interface { + Create(*SourceCodeCredential) (*SourceCodeCredential, error) + Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeCredential, error) + Update(*SourceCodeCredential) (*SourceCodeCredential, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SourceCodeCredentialList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SourceCodeCredentialClientCache + + OnCreate(ctx context.Context, name string, sync SourceCodeCredentialChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SourceCodeCredentialChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SourceCodeCredentialChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SourceCodeCredentialInterface +} + +type sourceCodeCredentialClientCache struct { + client *sourceCodeCredentialClient2 +} + +type sourceCodeCredentialClient2 struct { + iface SourceCodeCredentialInterface + controller SourceCodeCredentialController +} + +func (n *sourceCodeCredentialClient2) Interface() SourceCodeCredentialInterface { + return n.iface +} + +func (n *sourceCodeCredentialClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *sourceCodeCredentialClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *sourceCodeCredentialClient2) Create(obj *SourceCodeCredential) (*SourceCodeCredential, error) { + return n.iface.Create(obj) +} + +func (n *sourceCodeCredentialClient2) Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeCredential, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *sourceCodeCredentialClient2) Update(obj *SourceCodeCredential) (*SourceCodeCredential, error) { + return n.iface.Update(obj) +} + +func (n *sourceCodeCredentialClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *sourceCodeCredentialClient2) List(namespace string, opts metav1.ListOptions) (*SourceCodeCredentialList, error) { + return n.iface.List(opts) +} + +func (n *sourceCodeCredentialClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *sourceCodeCredentialClientCache) Get(namespace, name string) (*SourceCodeCredential, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *sourceCodeCredentialClientCache) List(namespace string, selector labels.Selector) ([]*SourceCodeCredential, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *sourceCodeCredentialClient2) Cache() SourceCodeCredentialClientCache { + n.loadController() + return &sourceCodeCredentialClientCache{ + client: n, + } +} + +func (n *sourceCodeCredentialClient2) OnCreate(ctx context.Context, name string, sync SourceCodeCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeCredentialLifecycleDelegate{create: sync}) +} + +func (n *sourceCodeCredentialClient2) OnChange(ctx context.Context, name string, sync SourceCodeCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeCredentialLifecycleDelegate{update: sync}) +} + +func (n *sourceCodeCredentialClient2) OnRemove(ctx context.Context, name string, sync SourceCodeCredentialChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeCredentialLifecycleDelegate{remove: sync}) +} + +func (n *sourceCodeCredentialClientCache) Index(name string, indexer SourceCodeCredentialIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*SourceCodeCredential); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *sourceCodeCredentialClientCache) GetIndexed(name, key string) ([]*SourceCodeCredential, error) { + var result []*SourceCodeCredential + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*SourceCodeCredential); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *sourceCodeCredentialClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type sourceCodeCredentialLifecycleDelegate struct { + create SourceCodeCredentialChangeHandlerFunc + update SourceCodeCredentialChangeHandlerFunc + remove SourceCodeCredentialChangeHandlerFunc +} + +func (n *sourceCodeCredentialLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *sourceCodeCredentialLifecycleDelegate) Create(obj *SourceCodeCredential) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *sourceCodeCredentialLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *sourceCodeCredentialLifecycleDelegate) Remove(obj *SourceCodeCredential) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *sourceCodeCredentialLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *sourceCodeCredentialLifecycleDelegate) Updated(obj *SourceCodeCredential) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_controller.go b/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_controller.go index 155feb92..32f1bbd9 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_controller.go @@ -37,6 +37,8 @@ type SourceCodeProviderConfigList struct { type SourceCodeProviderConfigHandlerFunc func(key string, obj *SourceCodeProviderConfig) (runtime.Object, error) +type SourceCodeProviderConfigChangeHandlerFunc func(obj *SourceCodeProviderConfig) (runtime.Object, error) + type SourceCodeProviderConfigLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeProviderConfig, err error) Get(namespace, name string) (*SourceCodeProviderConfig, error) @@ -248,3 +250,182 @@ func (s *sourceCodeProviderConfigClient) AddClusterScopedLifecycle(ctx context.C sync := NewSourceCodeProviderConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SourceCodeProviderConfigIndexer func(obj *SourceCodeProviderConfig) ([]string, error) + +type SourceCodeProviderConfigClientCache interface { + Get(namespace, name string) (*SourceCodeProviderConfig, error) + List(namespace string, selector labels.Selector) ([]*SourceCodeProviderConfig, error) + + Index(name string, indexer SourceCodeProviderConfigIndexer) + GetIndexed(name, key string) ([]*SourceCodeProviderConfig, error) +} + +type SourceCodeProviderConfigClient interface { + Create(*SourceCodeProviderConfig) (*SourceCodeProviderConfig, error) + Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeProviderConfig, error) + Update(*SourceCodeProviderConfig) (*SourceCodeProviderConfig, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SourceCodeProviderConfigList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SourceCodeProviderConfigClientCache + + OnCreate(ctx context.Context, name string, sync SourceCodeProviderConfigChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SourceCodeProviderConfigChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SourceCodeProviderConfigChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SourceCodeProviderConfigInterface +} + +type sourceCodeProviderConfigClientCache struct { + client *sourceCodeProviderConfigClient2 +} + +type sourceCodeProviderConfigClient2 struct { + iface SourceCodeProviderConfigInterface + controller SourceCodeProviderConfigController +} + +func (n *sourceCodeProviderConfigClient2) Interface() SourceCodeProviderConfigInterface { + return n.iface +} + +func (n *sourceCodeProviderConfigClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *sourceCodeProviderConfigClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *sourceCodeProviderConfigClient2) Create(obj *SourceCodeProviderConfig) (*SourceCodeProviderConfig, error) { + return n.iface.Create(obj) +} + +func (n *sourceCodeProviderConfigClient2) Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeProviderConfig, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *sourceCodeProviderConfigClient2) Update(obj *SourceCodeProviderConfig) (*SourceCodeProviderConfig, error) { + return n.iface.Update(obj) +} + +func (n *sourceCodeProviderConfigClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *sourceCodeProviderConfigClient2) List(namespace string, opts metav1.ListOptions) (*SourceCodeProviderConfigList, error) { + return n.iface.List(opts) +} + +func (n *sourceCodeProviderConfigClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *sourceCodeProviderConfigClientCache) Get(namespace, name string) (*SourceCodeProviderConfig, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *sourceCodeProviderConfigClientCache) List(namespace string, selector labels.Selector) ([]*SourceCodeProviderConfig, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *sourceCodeProviderConfigClient2) Cache() SourceCodeProviderConfigClientCache { + n.loadController() + return &sourceCodeProviderConfigClientCache{ + client: n, + } +} + +func (n *sourceCodeProviderConfigClient2) OnCreate(ctx context.Context, name string, sync SourceCodeProviderConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeProviderConfigLifecycleDelegate{create: sync}) +} + +func (n *sourceCodeProviderConfigClient2) OnChange(ctx context.Context, name string, sync SourceCodeProviderConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeProviderConfigLifecycleDelegate{update: sync}) +} + +func (n *sourceCodeProviderConfigClient2) OnRemove(ctx context.Context, name string, sync SourceCodeProviderConfigChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeProviderConfigLifecycleDelegate{remove: sync}) +} + +func (n *sourceCodeProviderConfigClientCache) Index(name string, indexer SourceCodeProviderConfigIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*SourceCodeProviderConfig); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *sourceCodeProviderConfigClientCache) GetIndexed(name, key string) ([]*SourceCodeProviderConfig, error) { + var result []*SourceCodeProviderConfig + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*SourceCodeProviderConfig); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *sourceCodeProviderConfigClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type sourceCodeProviderConfigLifecycleDelegate struct { + create SourceCodeProviderConfigChangeHandlerFunc + update SourceCodeProviderConfigChangeHandlerFunc + remove SourceCodeProviderConfigChangeHandlerFunc +} + +func (n *sourceCodeProviderConfigLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *sourceCodeProviderConfigLifecycleDelegate) Create(obj *SourceCodeProviderConfig) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *sourceCodeProviderConfigLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *sourceCodeProviderConfigLifecycleDelegate) Remove(obj *SourceCodeProviderConfig) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *sourceCodeProviderConfigLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *sourceCodeProviderConfigLifecycleDelegate) Updated(obj *SourceCodeProviderConfig) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_provider_controller.go b/apis/project.cattle.io/v3/zz_generated_source_code_provider_controller.go index a077b306..f5c819ac 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_provider_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_provider_controller.go @@ -36,6 +36,8 @@ type SourceCodeProviderList struct { type SourceCodeProviderHandlerFunc func(key string, obj *SourceCodeProvider) (runtime.Object, error) +type SourceCodeProviderChangeHandlerFunc func(obj *SourceCodeProvider) (runtime.Object, error) + type SourceCodeProviderLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeProvider, err error) Get(namespace, name string) (*SourceCodeProvider, error) @@ -247,3 +249,182 @@ func (s *sourceCodeProviderClient) AddClusterScopedLifecycle(ctx context.Context sync := NewSourceCodeProviderLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SourceCodeProviderIndexer func(obj *SourceCodeProvider) ([]string, error) + +type SourceCodeProviderClientCache interface { + Get(namespace, name string) (*SourceCodeProvider, error) + List(namespace string, selector labels.Selector) ([]*SourceCodeProvider, error) + + Index(name string, indexer SourceCodeProviderIndexer) + GetIndexed(name, key string) ([]*SourceCodeProvider, error) +} + +type SourceCodeProviderClient interface { + Create(*SourceCodeProvider) (*SourceCodeProvider, error) + Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeProvider, error) + Update(*SourceCodeProvider) (*SourceCodeProvider, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SourceCodeProviderList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SourceCodeProviderClientCache + + OnCreate(ctx context.Context, name string, sync SourceCodeProviderChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SourceCodeProviderChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SourceCodeProviderChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SourceCodeProviderInterface +} + +type sourceCodeProviderClientCache struct { + client *sourceCodeProviderClient2 +} + +type sourceCodeProviderClient2 struct { + iface SourceCodeProviderInterface + controller SourceCodeProviderController +} + +func (n *sourceCodeProviderClient2) Interface() SourceCodeProviderInterface { + return n.iface +} + +func (n *sourceCodeProviderClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *sourceCodeProviderClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *sourceCodeProviderClient2) Create(obj *SourceCodeProvider) (*SourceCodeProvider, error) { + return n.iface.Create(obj) +} + +func (n *sourceCodeProviderClient2) Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeProvider, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *sourceCodeProviderClient2) Update(obj *SourceCodeProvider) (*SourceCodeProvider, error) { + return n.iface.Update(obj) +} + +func (n *sourceCodeProviderClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *sourceCodeProviderClient2) List(namespace string, opts metav1.ListOptions) (*SourceCodeProviderList, error) { + return n.iface.List(opts) +} + +func (n *sourceCodeProviderClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *sourceCodeProviderClientCache) Get(namespace, name string) (*SourceCodeProvider, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *sourceCodeProviderClientCache) List(namespace string, selector labels.Selector) ([]*SourceCodeProvider, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *sourceCodeProviderClient2) Cache() SourceCodeProviderClientCache { + n.loadController() + return &sourceCodeProviderClientCache{ + client: n, + } +} + +func (n *sourceCodeProviderClient2) OnCreate(ctx context.Context, name string, sync SourceCodeProviderChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeProviderLifecycleDelegate{create: sync}) +} + +func (n *sourceCodeProviderClient2) OnChange(ctx context.Context, name string, sync SourceCodeProviderChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeProviderLifecycleDelegate{update: sync}) +} + +func (n *sourceCodeProviderClient2) OnRemove(ctx context.Context, name string, sync SourceCodeProviderChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeProviderLifecycleDelegate{remove: sync}) +} + +func (n *sourceCodeProviderClientCache) Index(name string, indexer SourceCodeProviderIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*SourceCodeProvider); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *sourceCodeProviderClientCache) GetIndexed(name, key string) ([]*SourceCodeProvider, error) { + var result []*SourceCodeProvider + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*SourceCodeProvider); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *sourceCodeProviderClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type sourceCodeProviderLifecycleDelegate struct { + create SourceCodeProviderChangeHandlerFunc + update SourceCodeProviderChangeHandlerFunc + remove SourceCodeProviderChangeHandlerFunc +} + +func (n *sourceCodeProviderLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *sourceCodeProviderLifecycleDelegate) Create(obj *SourceCodeProvider) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *sourceCodeProviderLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *sourceCodeProviderLifecycleDelegate) Remove(obj *SourceCodeProvider) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *sourceCodeProviderLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *sourceCodeProviderLifecycleDelegate) Updated(obj *SourceCodeProvider) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_repository_controller.go b/apis/project.cattle.io/v3/zz_generated_source_code_repository_controller.go index 0f717b29..c2657599 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_repository_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_repository_controller.go @@ -37,6 +37,8 @@ type SourceCodeRepositoryList struct { type SourceCodeRepositoryHandlerFunc func(key string, obj *SourceCodeRepository) (runtime.Object, error) +type SourceCodeRepositoryChangeHandlerFunc func(obj *SourceCodeRepository) (runtime.Object, error) + type SourceCodeRepositoryLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeRepository, err error) Get(namespace, name string) (*SourceCodeRepository, error) @@ -248,3 +250,182 @@ func (s *sourceCodeRepositoryClient) AddClusterScopedLifecycle(ctx context.Conte sync := NewSourceCodeRepositoryLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SourceCodeRepositoryIndexer func(obj *SourceCodeRepository) ([]string, error) + +type SourceCodeRepositoryClientCache interface { + Get(namespace, name string) (*SourceCodeRepository, error) + List(namespace string, selector labels.Selector) ([]*SourceCodeRepository, error) + + Index(name string, indexer SourceCodeRepositoryIndexer) + GetIndexed(name, key string) ([]*SourceCodeRepository, error) +} + +type SourceCodeRepositoryClient interface { + Create(*SourceCodeRepository) (*SourceCodeRepository, error) + Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeRepository, error) + Update(*SourceCodeRepository) (*SourceCodeRepository, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SourceCodeRepositoryList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SourceCodeRepositoryClientCache + + OnCreate(ctx context.Context, name string, sync SourceCodeRepositoryChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SourceCodeRepositoryChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SourceCodeRepositoryChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SourceCodeRepositoryInterface +} + +type sourceCodeRepositoryClientCache struct { + client *sourceCodeRepositoryClient2 +} + +type sourceCodeRepositoryClient2 struct { + iface SourceCodeRepositoryInterface + controller SourceCodeRepositoryController +} + +func (n *sourceCodeRepositoryClient2) Interface() SourceCodeRepositoryInterface { + return n.iface +} + +func (n *sourceCodeRepositoryClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *sourceCodeRepositoryClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *sourceCodeRepositoryClient2) Create(obj *SourceCodeRepository) (*SourceCodeRepository, error) { + return n.iface.Create(obj) +} + +func (n *sourceCodeRepositoryClient2) Get(namespace, name string, opts metav1.GetOptions) (*SourceCodeRepository, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *sourceCodeRepositoryClient2) Update(obj *SourceCodeRepository) (*SourceCodeRepository, error) { + return n.iface.Update(obj) +} + +func (n *sourceCodeRepositoryClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *sourceCodeRepositoryClient2) List(namespace string, opts metav1.ListOptions) (*SourceCodeRepositoryList, error) { + return n.iface.List(opts) +} + +func (n *sourceCodeRepositoryClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *sourceCodeRepositoryClientCache) Get(namespace, name string) (*SourceCodeRepository, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *sourceCodeRepositoryClientCache) List(namespace string, selector labels.Selector) ([]*SourceCodeRepository, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *sourceCodeRepositoryClient2) Cache() SourceCodeRepositoryClientCache { + n.loadController() + return &sourceCodeRepositoryClientCache{ + client: n, + } +} + +func (n *sourceCodeRepositoryClient2) OnCreate(ctx context.Context, name string, sync SourceCodeRepositoryChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeRepositoryLifecycleDelegate{create: sync}) +} + +func (n *sourceCodeRepositoryClient2) OnChange(ctx context.Context, name string, sync SourceCodeRepositoryChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeRepositoryLifecycleDelegate{update: sync}) +} + +func (n *sourceCodeRepositoryClient2) OnRemove(ctx context.Context, name string, sync SourceCodeRepositoryChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sourceCodeRepositoryLifecycleDelegate{remove: sync}) +} + +func (n *sourceCodeRepositoryClientCache) Index(name string, indexer SourceCodeRepositoryIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*SourceCodeRepository); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *sourceCodeRepositoryClientCache) GetIndexed(name, key string) ([]*SourceCodeRepository, error) { + var result []*SourceCodeRepository + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*SourceCodeRepository); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *sourceCodeRepositoryClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type sourceCodeRepositoryLifecycleDelegate struct { + create SourceCodeRepositoryChangeHandlerFunc + update SourceCodeRepositoryChangeHandlerFunc + remove SourceCodeRepositoryChangeHandlerFunc +} + +func (n *sourceCodeRepositoryLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *sourceCodeRepositoryLifecycleDelegate) Create(obj *SourceCodeRepository) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *sourceCodeRepositoryLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *sourceCodeRepositoryLifecycleDelegate) Remove(obj *SourceCodeRepository) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *sourceCodeRepositoryLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *sourceCodeRepositoryLifecycleDelegate) Updated(obj *SourceCodeRepository) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_ssh_auth_controller.go b/apis/project.cattle.io/v3/zz_generated_ssh_auth_controller.go index ec45d3f7..554ccf5e 100644 --- a/apis/project.cattle.io/v3/zz_generated_ssh_auth_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_ssh_auth_controller.go @@ -37,6 +37,8 @@ type SSHAuthList struct { type SSHAuthHandlerFunc func(key string, obj *SSHAuth) (runtime.Object, error) +type SSHAuthChangeHandlerFunc func(obj *SSHAuth) (runtime.Object, error) + type SSHAuthLister interface { List(namespace string, selector labels.Selector) (ret []*SSHAuth, err error) Get(namespace, name string) (*SSHAuth, error) @@ -248,3 +250,182 @@ func (s *sshAuthClient) AddClusterScopedLifecycle(ctx context.Context, name, clu sync := NewSSHAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type SSHAuthIndexer func(obj *SSHAuth) ([]string, error) + +type SSHAuthClientCache interface { + Get(namespace, name string) (*SSHAuth, error) + List(namespace string, selector labels.Selector) ([]*SSHAuth, error) + + Index(name string, indexer SSHAuthIndexer) + GetIndexed(name, key string) ([]*SSHAuth, error) +} + +type SSHAuthClient interface { + Create(*SSHAuth) (*SSHAuth, error) + Get(namespace, name string, opts metav1.GetOptions) (*SSHAuth, error) + Update(*SSHAuth) (*SSHAuth, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*SSHAuthList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() SSHAuthClientCache + + OnCreate(ctx context.Context, name string, sync SSHAuthChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync SSHAuthChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync SSHAuthChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() SSHAuthInterface +} + +type sshAuthClientCache struct { + client *sshAuthClient2 +} + +type sshAuthClient2 struct { + iface SSHAuthInterface + controller SSHAuthController +} + +func (n *sshAuthClient2) Interface() SSHAuthInterface { + return n.iface +} + +func (n *sshAuthClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *sshAuthClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *sshAuthClient2) Create(obj *SSHAuth) (*SSHAuth, error) { + return n.iface.Create(obj) +} + +func (n *sshAuthClient2) Get(namespace, name string, opts metav1.GetOptions) (*SSHAuth, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *sshAuthClient2) Update(obj *SSHAuth) (*SSHAuth, error) { + return n.iface.Update(obj) +} + +func (n *sshAuthClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *sshAuthClient2) List(namespace string, opts metav1.ListOptions) (*SSHAuthList, error) { + return n.iface.List(opts) +} + +func (n *sshAuthClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *sshAuthClientCache) Get(namespace, name string) (*SSHAuth, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *sshAuthClientCache) List(namespace string, selector labels.Selector) ([]*SSHAuth, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *sshAuthClient2) Cache() SSHAuthClientCache { + n.loadController() + return &sshAuthClientCache{ + client: n, + } +} + +func (n *sshAuthClient2) OnCreate(ctx context.Context, name string, sync SSHAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sshAuthLifecycleDelegate{create: sync}) +} + +func (n *sshAuthClient2) OnChange(ctx context.Context, name string, sync SSHAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sshAuthLifecycleDelegate{update: sync}) +} + +func (n *sshAuthClient2) OnRemove(ctx context.Context, name string, sync SSHAuthChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &sshAuthLifecycleDelegate{remove: sync}) +} + +func (n *sshAuthClientCache) Index(name string, indexer SSHAuthIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*SSHAuth); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *sshAuthClientCache) GetIndexed(name, key string) ([]*SSHAuth, error) { + var result []*SSHAuth + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*SSHAuth); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *sshAuthClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type sshAuthLifecycleDelegate struct { + create SSHAuthChangeHandlerFunc + update SSHAuthChangeHandlerFunc + remove SSHAuthChangeHandlerFunc +} + +func (n *sshAuthLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *sshAuthLifecycleDelegate) Create(obj *SSHAuth) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *sshAuthLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *sshAuthLifecycleDelegate) Remove(obj *SSHAuth) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *sshAuthLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *sshAuthLifecycleDelegate) Updated(obj *SSHAuth) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/project.cattle.io/v3/zz_generated_workload_controller.go b/apis/project.cattle.io/v3/zz_generated_workload_controller.go index b2499c87..3d481b8f 100644 --- a/apis/project.cattle.io/v3/zz_generated_workload_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_workload_controller.go @@ -37,6 +37,8 @@ type WorkloadList struct { type WorkloadHandlerFunc func(key string, obj *Workload) (runtime.Object, error) +type WorkloadChangeHandlerFunc func(obj *Workload) (runtime.Object, error) + type WorkloadLister interface { List(namespace string, selector labels.Selector) (ret []*Workload, err error) Get(namespace, name string) (*Workload, error) @@ -248,3 +250,182 @@ func (s *workloadClient) AddClusterScopedLifecycle(ctx context.Context, name, cl sync := NewWorkloadLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type WorkloadIndexer func(obj *Workload) ([]string, error) + +type WorkloadClientCache interface { + Get(namespace, name string) (*Workload, error) + List(namespace string, selector labels.Selector) ([]*Workload, error) + + Index(name string, indexer WorkloadIndexer) + GetIndexed(name, key string) ([]*Workload, error) +} + +type WorkloadClient interface { + Create(*Workload) (*Workload, error) + Get(namespace, name string, opts metav1.GetOptions) (*Workload, error) + Update(*Workload) (*Workload, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*WorkloadList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() WorkloadClientCache + + OnCreate(ctx context.Context, name string, sync WorkloadChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync WorkloadChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync WorkloadChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() WorkloadInterface +} + +type workloadClientCache struct { + client *workloadClient2 +} + +type workloadClient2 struct { + iface WorkloadInterface + controller WorkloadController +} + +func (n *workloadClient2) Interface() WorkloadInterface { + return n.iface +} + +func (n *workloadClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *workloadClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *workloadClient2) Create(obj *Workload) (*Workload, error) { + return n.iface.Create(obj) +} + +func (n *workloadClient2) Get(namespace, name string, opts metav1.GetOptions) (*Workload, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *workloadClient2) Update(obj *Workload) (*Workload, error) { + return n.iface.Update(obj) +} + +func (n *workloadClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *workloadClient2) List(namespace string, opts metav1.ListOptions) (*WorkloadList, error) { + return n.iface.List(opts) +} + +func (n *workloadClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *workloadClientCache) Get(namespace, name string) (*Workload, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *workloadClientCache) List(namespace string, selector labels.Selector) ([]*Workload, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *workloadClient2) Cache() WorkloadClientCache { + n.loadController() + return &workloadClientCache{ + client: n, + } +} + +func (n *workloadClient2) OnCreate(ctx context.Context, name string, sync WorkloadChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &workloadLifecycleDelegate{create: sync}) +} + +func (n *workloadClient2) OnChange(ctx context.Context, name string, sync WorkloadChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &workloadLifecycleDelegate{update: sync}) +} + +func (n *workloadClient2) OnRemove(ctx context.Context, name string, sync WorkloadChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &workloadLifecycleDelegate{remove: sync}) +} + +func (n *workloadClientCache) Index(name string, indexer WorkloadIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*Workload); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *workloadClientCache) GetIndexed(name, key string) ([]*Workload, error) { + var result []*Workload + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*Workload); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *workloadClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type workloadLifecycleDelegate struct { + create WorkloadChangeHandlerFunc + update WorkloadChangeHandlerFunc + remove WorkloadChangeHandlerFunc +} + +func (n *workloadLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *workloadLifecycleDelegate) Create(obj *Workload) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *workloadLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *workloadLifecycleDelegate) Remove(obj *Workload) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *workloadLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *workloadLifecycleDelegate) Updated(obj *Workload) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_controller.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_controller.go index c6f7121d..2c804fcb 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_controller.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_controller.go @@ -37,6 +37,8 @@ type ClusterRoleBindingList struct { type ClusterRoleBindingHandlerFunc func(key string, obj *v1.ClusterRoleBinding) (runtime.Object, error) +type ClusterRoleBindingChangeHandlerFunc func(obj *v1.ClusterRoleBinding) (runtime.Object, error) + type ClusterRoleBindingLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ClusterRoleBinding, err error) Get(namespace, name string) (*v1.ClusterRoleBinding, error) @@ -248,3 +250,182 @@ func (s *clusterRoleBindingClient) AddClusterScopedLifecycle(ctx context.Context sync := NewClusterRoleBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterRoleBindingIndexer func(obj *v1.ClusterRoleBinding) ([]string, error) + +type ClusterRoleBindingClientCache interface { + Get(namespace, name string) (*v1.ClusterRoleBinding, error) + List(namespace string, selector labels.Selector) ([]*v1.ClusterRoleBinding, error) + + Index(name string, indexer ClusterRoleBindingIndexer) + GetIndexed(name, key string) ([]*v1.ClusterRoleBinding, error) +} + +type ClusterRoleBindingClient interface { + Create(*v1.ClusterRoleBinding) (*v1.ClusterRoleBinding, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ClusterRoleBinding, error) + Update(*v1.ClusterRoleBinding) (*v1.ClusterRoleBinding, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterRoleBindingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterRoleBindingClientCache + + OnCreate(ctx context.Context, name string, sync ClusterRoleBindingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterRoleBindingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterRoleBindingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterRoleBindingInterface +} + +type clusterRoleBindingClientCache struct { + client *clusterRoleBindingClient2 +} + +type clusterRoleBindingClient2 struct { + iface ClusterRoleBindingInterface + controller ClusterRoleBindingController +} + +func (n *clusterRoleBindingClient2) Interface() ClusterRoleBindingInterface { + return n.iface +} + +func (n *clusterRoleBindingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterRoleBindingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterRoleBindingClient2) Create(obj *v1.ClusterRoleBinding) (*v1.ClusterRoleBinding, error) { + return n.iface.Create(obj) +} + +func (n *clusterRoleBindingClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ClusterRoleBinding, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterRoleBindingClient2) Update(obj *v1.ClusterRoleBinding) (*v1.ClusterRoleBinding, error) { + return n.iface.Update(obj) +} + +func (n *clusterRoleBindingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterRoleBindingClient2) List(namespace string, opts metav1.ListOptions) (*ClusterRoleBindingList, error) { + return n.iface.List(opts) +} + +func (n *clusterRoleBindingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterRoleBindingClientCache) Get(namespace, name string) (*v1.ClusterRoleBinding, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterRoleBindingClientCache) List(namespace string, selector labels.Selector) ([]*v1.ClusterRoleBinding, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterRoleBindingClient2) Cache() ClusterRoleBindingClientCache { + n.loadController() + return &clusterRoleBindingClientCache{ + client: n, + } +} + +func (n *clusterRoleBindingClient2) OnCreate(ctx context.Context, name string, sync ClusterRoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleBindingLifecycleDelegate{create: sync}) +} + +func (n *clusterRoleBindingClient2) OnChange(ctx context.Context, name string, sync ClusterRoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleBindingLifecycleDelegate{update: sync}) +} + +func (n *clusterRoleBindingClient2) OnRemove(ctx context.Context, name string, sync ClusterRoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleBindingLifecycleDelegate{remove: sync}) +} + +func (n *clusterRoleBindingClientCache) Index(name string, indexer ClusterRoleBindingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ClusterRoleBinding); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterRoleBindingClientCache) GetIndexed(name, key string) ([]*v1.ClusterRoleBinding, error) { + var result []*v1.ClusterRoleBinding + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ClusterRoleBinding); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterRoleBindingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterRoleBindingLifecycleDelegate struct { + create ClusterRoleBindingChangeHandlerFunc + update ClusterRoleBindingChangeHandlerFunc + remove ClusterRoleBindingChangeHandlerFunc +} + +func (n *clusterRoleBindingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterRoleBindingLifecycleDelegate) Create(obj *v1.ClusterRoleBinding) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterRoleBindingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterRoleBindingLifecycleDelegate) Remove(obj *v1.ClusterRoleBinding) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterRoleBindingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterRoleBindingLifecycleDelegate) Updated(obj *v1.ClusterRoleBinding) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_controller.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_controller.go index 1906c1ed..67fd0713 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_controller.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_controller.go @@ -37,6 +37,8 @@ type ClusterRoleList struct { type ClusterRoleHandlerFunc func(key string, obj *v1.ClusterRole) (runtime.Object, error) +type ClusterRoleChangeHandlerFunc func(obj *v1.ClusterRole) (runtime.Object, error) + type ClusterRoleLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ClusterRole, err error) Get(namespace, name string) (*v1.ClusterRole, error) @@ -248,3 +250,182 @@ func (s *clusterRoleClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewClusterRoleLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type ClusterRoleIndexer func(obj *v1.ClusterRole) ([]string, error) + +type ClusterRoleClientCache interface { + Get(namespace, name string) (*v1.ClusterRole, error) + List(namespace string, selector labels.Selector) ([]*v1.ClusterRole, error) + + Index(name string, indexer ClusterRoleIndexer) + GetIndexed(name, key string) ([]*v1.ClusterRole, error) +} + +type ClusterRoleClient interface { + Create(*v1.ClusterRole) (*v1.ClusterRole, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.ClusterRole, error) + Update(*v1.ClusterRole) (*v1.ClusterRole, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*ClusterRoleList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() ClusterRoleClientCache + + OnCreate(ctx context.Context, name string, sync ClusterRoleChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync ClusterRoleChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync ClusterRoleChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() ClusterRoleInterface +} + +type clusterRoleClientCache struct { + client *clusterRoleClient2 +} + +type clusterRoleClient2 struct { + iface ClusterRoleInterface + controller ClusterRoleController +} + +func (n *clusterRoleClient2) Interface() ClusterRoleInterface { + return n.iface +} + +func (n *clusterRoleClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *clusterRoleClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *clusterRoleClient2) Create(obj *v1.ClusterRole) (*v1.ClusterRole, error) { + return n.iface.Create(obj) +} + +func (n *clusterRoleClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.ClusterRole, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *clusterRoleClient2) Update(obj *v1.ClusterRole) (*v1.ClusterRole, error) { + return n.iface.Update(obj) +} + +func (n *clusterRoleClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *clusterRoleClient2) List(namespace string, opts metav1.ListOptions) (*ClusterRoleList, error) { + return n.iface.List(opts) +} + +func (n *clusterRoleClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *clusterRoleClientCache) Get(namespace, name string) (*v1.ClusterRole, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *clusterRoleClientCache) List(namespace string, selector labels.Selector) ([]*v1.ClusterRole, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *clusterRoleClient2) Cache() ClusterRoleClientCache { + n.loadController() + return &clusterRoleClientCache{ + client: n, + } +} + +func (n *clusterRoleClient2) OnCreate(ctx context.Context, name string, sync ClusterRoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleLifecycleDelegate{create: sync}) +} + +func (n *clusterRoleClient2) OnChange(ctx context.Context, name string, sync ClusterRoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleLifecycleDelegate{update: sync}) +} + +func (n *clusterRoleClient2) OnRemove(ctx context.Context, name string, sync ClusterRoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &clusterRoleLifecycleDelegate{remove: sync}) +} + +func (n *clusterRoleClientCache) Index(name string, indexer ClusterRoleIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.ClusterRole); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *clusterRoleClientCache) GetIndexed(name, key string) ([]*v1.ClusterRole, error) { + var result []*v1.ClusterRole + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.ClusterRole); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *clusterRoleClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type clusterRoleLifecycleDelegate struct { + create ClusterRoleChangeHandlerFunc + update ClusterRoleChangeHandlerFunc + remove ClusterRoleChangeHandlerFunc +} + +func (n *clusterRoleLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *clusterRoleLifecycleDelegate) Create(obj *v1.ClusterRole) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *clusterRoleLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *clusterRoleLifecycleDelegate) Remove(obj *v1.ClusterRole) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *clusterRoleLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *clusterRoleLifecycleDelegate) Updated(obj *v1.ClusterRole) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_k8s_client.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_k8s_client.go index ff5e7464..604399e8 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_k8s_client.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_k8s_client.go @@ -11,7 +11,10 @@ import ( "k8s.io/client-go/rest" ) -type contextKeyType struct{} +type ( + contextKeyType struct{} + contextClientsKeyType struct{} +) type Interface interface { RESTClient() rest.Interface @@ -23,6 +26,13 @@ type Interface interface { RolesGetter } +type Clients struct { + ClusterRoleBinding ClusterRoleBindingClient + ClusterRole ClusterRoleClient + RoleBinding RoleBindingClient + Role RoleClient +} + type Client struct { sync.Mutex restClient rest.Interface @@ -40,13 +50,47 @@ func Factory(ctx context.Context, config rest.Config) (context.Context, controll return ctx, nil, err } - return context.WithValue(ctx, contextKeyType{}, c), c, nil + cs := NewClientsFromInterface(c) + + ctx = context.WithValue(ctx, contextKeyType{}, c) + ctx = context.WithValue(ctx, contextClientsKeyType{}, cs) + return ctx, c, nil +} + +func ClientsFrom(ctx context.Context) *Clients { + return ctx.Value(contextClientsKeyType{}).(*Clients) } func From(ctx context.Context) Interface { return ctx.Value(contextKeyType{}).(Interface) } +func NewClients(config rest.Config) (*Clients, error) { + iface, err := NewForConfig(config) + if err != nil { + return nil, err + } + return NewClientsFromInterface(iface), nil +} + +func NewClientsFromInterface(iface Interface) *Clients { + return &Clients{ + + ClusterRoleBinding: &clusterRoleBindingClient2{ + iface: iface.ClusterRoleBindings(""), + }, + ClusterRole: &clusterRoleClient2{ + iface: iface.ClusterRoles(""), + }, + RoleBinding: &roleBindingClient2{ + iface: iface.RoleBindings(""), + }, + Role: &roleClient2{ + iface: iface.Roles(""), + }, + } +} + func NewForConfig(config rest.Config) (Interface, error) { if config.NegotiatedSerializer == nil { config.NegotiatedSerializer = dynamic.NegotiatedSerializer diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_controller.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_controller.go index 98ba7404..60d4bf67 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_controller.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_controller.go @@ -38,6 +38,8 @@ type RoleBindingList struct { type RoleBindingHandlerFunc func(key string, obj *v1.RoleBinding) (runtime.Object, error) +type RoleBindingChangeHandlerFunc func(obj *v1.RoleBinding) (runtime.Object, error) + type RoleBindingLister interface { List(namespace string, selector labels.Selector) (ret []*v1.RoleBinding, err error) Get(namespace, name string) (*v1.RoleBinding, error) @@ -249,3 +251,182 @@ func (s *roleBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, sync := NewRoleBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type RoleBindingIndexer func(obj *v1.RoleBinding) ([]string, error) + +type RoleBindingClientCache interface { + Get(namespace, name string) (*v1.RoleBinding, error) + List(namespace string, selector labels.Selector) ([]*v1.RoleBinding, error) + + Index(name string, indexer RoleBindingIndexer) + GetIndexed(name, key string) ([]*v1.RoleBinding, error) +} + +type RoleBindingClient interface { + Create(*v1.RoleBinding) (*v1.RoleBinding, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.RoleBinding, error) + Update(*v1.RoleBinding) (*v1.RoleBinding, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*RoleBindingList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() RoleBindingClientCache + + OnCreate(ctx context.Context, name string, sync RoleBindingChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync RoleBindingChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync RoleBindingChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() RoleBindingInterface +} + +type roleBindingClientCache struct { + client *roleBindingClient2 +} + +type roleBindingClient2 struct { + iface RoleBindingInterface + controller RoleBindingController +} + +func (n *roleBindingClient2) Interface() RoleBindingInterface { + return n.iface +} + +func (n *roleBindingClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *roleBindingClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *roleBindingClient2) Create(obj *v1.RoleBinding) (*v1.RoleBinding, error) { + return n.iface.Create(obj) +} + +func (n *roleBindingClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.RoleBinding, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *roleBindingClient2) Update(obj *v1.RoleBinding) (*v1.RoleBinding, error) { + return n.iface.Update(obj) +} + +func (n *roleBindingClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *roleBindingClient2) List(namespace string, opts metav1.ListOptions) (*RoleBindingList, error) { + return n.iface.List(opts) +} + +func (n *roleBindingClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *roleBindingClientCache) Get(namespace, name string) (*v1.RoleBinding, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *roleBindingClientCache) List(namespace string, selector labels.Selector) ([]*v1.RoleBinding, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *roleBindingClient2) Cache() RoleBindingClientCache { + n.loadController() + return &roleBindingClientCache{ + client: n, + } +} + +func (n *roleBindingClient2) OnCreate(ctx context.Context, name string, sync RoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleBindingLifecycleDelegate{create: sync}) +} + +func (n *roleBindingClient2) OnChange(ctx context.Context, name string, sync RoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleBindingLifecycleDelegate{update: sync}) +} + +func (n *roleBindingClient2) OnRemove(ctx context.Context, name string, sync RoleBindingChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleBindingLifecycleDelegate{remove: sync}) +} + +func (n *roleBindingClientCache) Index(name string, indexer RoleBindingIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.RoleBinding); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *roleBindingClientCache) GetIndexed(name, key string) ([]*v1.RoleBinding, error) { + var result []*v1.RoleBinding + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.RoleBinding); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *roleBindingClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type roleBindingLifecycleDelegate struct { + create RoleBindingChangeHandlerFunc + update RoleBindingChangeHandlerFunc + remove RoleBindingChangeHandlerFunc +} + +func (n *roleBindingLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *roleBindingLifecycleDelegate) Create(obj *v1.RoleBinding) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *roleBindingLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *roleBindingLifecycleDelegate) Remove(obj *v1.RoleBinding) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *roleBindingLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *roleBindingLifecycleDelegate) Updated(obj *v1.RoleBinding) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +} diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_controller.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_controller.go index a555b6bc..8af6a228 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_controller.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_controller.go @@ -38,6 +38,8 @@ type RoleList struct { type RoleHandlerFunc func(key string, obj *v1.Role) (runtime.Object, error) +type RoleChangeHandlerFunc func(obj *v1.Role) (runtime.Object, error) + type RoleLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Role, err error) Get(namespace, name string) (*v1.Role, error) @@ -249,3 +251,182 @@ func (s *roleClient) AddClusterScopedLifecycle(ctx context.Context, name, cluste sync := NewRoleLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } + +type RoleIndexer func(obj *v1.Role) ([]string, error) + +type RoleClientCache interface { + Get(namespace, name string) (*v1.Role, error) + List(namespace string, selector labels.Selector) ([]*v1.Role, error) + + Index(name string, indexer RoleIndexer) + GetIndexed(name, key string) ([]*v1.Role, error) +} + +type RoleClient interface { + Create(*v1.Role) (*v1.Role, error) + Get(namespace, name string, opts metav1.GetOptions) (*v1.Role, error) + Update(*v1.Role) (*v1.Role, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + List(namespace string, opts metav1.ListOptions) (*RoleList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + + Cache() RoleClientCache + + OnCreate(ctx context.Context, name string, sync RoleChangeHandlerFunc) + OnChange(ctx context.Context, name string, sync RoleChangeHandlerFunc) + OnRemove(ctx context.Context, name string, sync RoleChangeHandlerFunc) + Enqueue(namespace, name string) + + Generic() controller.GenericController + Interface() RoleInterface +} + +type roleClientCache struct { + client *roleClient2 +} + +type roleClient2 struct { + iface RoleInterface + controller RoleController +} + +func (n *roleClient2) Interface() RoleInterface { + return n.iface +} + +func (n *roleClient2) Generic() controller.GenericController { + return n.iface.Controller().Generic() +} + +func (n *roleClient2) Enqueue(namespace, name string) { + n.iface.Controller().Enqueue(namespace, name) +} + +func (n *roleClient2) Create(obj *v1.Role) (*v1.Role, error) { + return n.iface.Create(obj) +} + +func (n *roleClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Role, error) { + return n.iface.GetNamespaced(namespace, name, opts) +} + +func (n *roleClient2) Update(obj *v1.Role) (*v1.Role, error) { + return n.iface.Update(obj) +} + +func (n *roleClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return n.iface.DeleteNamespaced(namespace, name, options) +} + +func (n *roleClient2) List(namespace string, opts metav1.ListOptions) (*RoleList, error) { + return n.iface.List(opts) +} + +func (n *roleClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return n.iface.Watch(opts) +} + +func (n *roleClientCache) Get(namespace, name string) (*v1.Role, error) { + return n.client.controller.Lister().Get(namespace, name) +} + +func (n *roleClientCache) List(namespace string, selector labels.Selector) ([]*v1.Role, error) { + return n.client.controller.Lister().List(namespace, selector) +} + +func (n *roleClient2) Cache() RoleClientCache { + n.loadController() + return &roleClientCache{ + client: n, + } +} + +func (n *roleClient2) OnCreate(ctx context.Context, name string, sync RoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleLifecycleDelegate{create: sync}) +} + +func (n *roleClient2) OnChange(ctx context.Context, name string, sync RoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleLifecycleDelegate{update: sync}) +} + +func (n *roleClient2) OnRemove(ctx context.Context, name string, sync RoleChangeHandlerFunc) { + n.loadController() + n.iface.AddLifecycle(ctx, name, &roleLifecycleDelegate{remove: sync}) +} + +func (n *roleClientCache) Index(name string, indexer RoleIndexer) { + err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{ + name: func(obj interface{}) ([]string, error) { + if v, ok := obj.(*v1.Role); ok { + return indexer(v) + } + return nil, nil + }, + }) + + if err != nil { + panic(err) + } +} + +func (n *roleClientCache) GetIndexed(name, key string) ([]*v1.Role, error) { + var result []*v1.Role + objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key) + if err != nil { + return nil, err + } + for _, obj := range objs { + if v, ok := obj.(*v1.Role); ok { + result = append(result, v) + } + } + + return result, nil +} + +func (n *roleClient2) loadController() { + if n.controller == nil { + n.controller = n.iface.Controller() + } +} + +type roleLifecycleDelegate struct { + create RoleChangeHandlerFunc + update RoleChangeHandlerFunc + remove RoleChangeHandlerFunc +} + +func (n *roleLifecycleDelegate) HasCreate() bool { + return n.create != nil +} + +func (n *roleLifecycleDelegate) Create(obj *v1.Role) (runtime.Object, error) { + if n.create == nil { + return obj, nil + } + return n.create(obj) +} + +func (n *roleLifecycleDelegate) HasFinalize() bool { + return n.remove != nil +} + +func (n *roleLifecycleDelegate) Remove(obj *v1.Role) (runtime.Object, error) { + if n.remove == nil { + return obj, nil + } + return n.remove(obj) +} + +func (n *roleLifecycleDelegate) HasUpdated() bool { + return n.remove != nil +} + +func (n *roleLifecycleDelegate) Updated(obj *v1.Role) (runtime.Object, error) { + if n.update == nil { + return obj, nil + } + return n.update(obj) +}