From abee9812f683d69fa5f54beede01f2f8fb914f16 Mon Sep 17 00:00:00 2001 From: Darren Shepherd Date: Tue, 30 Oct 2018 10:06:55 -0700 Subject: [PATCH] Update generated code --- .../zz_generated_daemon_set_controller.go | 65 +++++++++---------- ..._generated_daemon_set_lifecycle_adapter.go | 9 +-- .../zz_generated_deployment_controller.go | 65 +++++++++---------- ..._generated_deployment_lifecycle_adapter.go | 9 +-- .../zz_generated_replica_set_controller.go | 65 +++++++++---------- ...generated_replica_set_lifecycle_adapter.go | 9 +-- .../zz_generated_stateful_set_controller.go | 65 +++++++++---------- ...enerated_stateful_set_lifecycle_adapter.go | 9 +-- apis/batch/v1/zz_generated_job_controller.go | 65 +++++++++---------- .../v1/zz_generated_job_lifecycle_adapter.go | 9 +-- .../zz_generated_cron_job_controller.go | 65 +++++++++---------- ...zz_generated_cron_job_lifecycle_adapter.go | 9 +-- ...z_generated_component_status_controller.go | 65 +++++++++---------- ...ated_component_status_lifecycle_adapter.go | 9 +-- .../v1/zz_generated_config_map_controller.go | 65 +++++++++---------- ..._generated_config_map_lifecycle_adapter.go | 9 +-- .../v1/zz_generated_endpoints_controller.go | 65 +++++++++---------- ...z_generated_endpoints_lifecycle_adapter.go | 9 +-- apis/core/v1/zz_generated_event_controller.go | 65 +++++++++---------- .../zz_generated_event_lifecycle_adapter.go | 9 +-- .../v1/zz_generated_namespace_controller.go | 65 +++++++++---------- ...z_generated_namespace_lifecycle_adapter.go | 9 +-- apis/core/v1/zz_generated_node_controller.go | 65 +++++++++---------- .../v1/zz_generated_node_lifecycle_adapter.go | 9 +-- ...ated_persistent_volume_claim_controller.go | 65 +++++++++---------- ...rsistent_volume_claim_lifecycle_adapter.go | 9 +-- apis/core/v1/zz_generated_pod_controller.go | 65 +++++++++---------- .../v1/zz_generated_pod_lifecycle_adapter.go | 9 +-- ...rated_replication_controller_controller.go | 65 +++++++++---------- ...eplication_controller_lifecycle_adapter.go | 9 +-- .../zz_generated_resource_quota_controller.go | 65 +++++++++---------- ...erated_resource_quota_lifecycle_adapter.go | 9 +-- .../core/v1/zz_generated_secret_controller.go | 65 +++++++++---------- .../zz_generated_secret_lifecycle_adapter.go | 9 +-- ...zz_generated_service_account_controller.go | 65 +++++++++---------- ...rated_service_account_lifecycle_adapter.go | 9 +-- .../v1/zz_generated_service_controller.go | 65 +++++++++---------- .../zz_generated_service_lifecycle_adapter.go | 9 +-- .../zz_generated_ingress_controller.go | 65 +++++++++---------- .../zz_generated_ingress_lifecycle_adapter.go | 9 +-- ...enerated_pod_security_policy_controller.go | 65 +++++++++---------- ...d_pod_security_policy_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_auth_config_controller.go | 65 +++++++++---------- ...generated_auth_config_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_catalog_controller.go | 65 +++++++++---------- .../zz_generated_catalog_lifecycle_adapter.go | 9 +-- .../zz_generated_cluster_alert_controller.go | 65 +++++++++---------- ...nerated_cluster_alert_lifecycle_adapter.go | 9 +-- ...zz_generated_cluster_catalog_controller.go | 65 +++++++++---------- ...rated_cluster_catalog_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_cluster_controller.go | 65 +++++++++---------- .../zz_generated_cluster_lifecycle_adapter.go | 9 +-- ...zz_generated_cluster_logging_controller.go | 65 +++++++++---------- ...rated_cluster_logging_lifecycle_adapter.go | 9 +-- ...d_cluster_registration_token_controller.go | 65 +++++++++---------- ...er_registration_token_lifecycle_adapter.go | 9 +-- ...luster_role_template_binding_controller.go | 65 +++++++++---------- ...role_template_binding_lifecycle_adapter.go | 9 +-- .../zz_generated_compose_config_controller.go | 65 +++++++++---------- ...erated_compose_config_lifecycle_adapter.go | 9 +-- .../zz_generated_dynamic_schema_controller.go | 65 +++++++++---------- ...erated_dynamic_schema_lifecycle_adapter.go | 9 +-- ...enerated_global_role_binding_controller.go | 65 +++++++++---------- ...d_global_role_binding_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_global_role_controller.go | 65 +++++++++---------- ...generated_global_role_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_group_controller.go | 65 +++++++++---------- .../zz_generated_group_lifecycle_adapter.go | 9 +-- .../zz_generated_group_member_controller.go | 65 +++++++++---------- ...enerated_group_member_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_ldap_config_controller.go | 65 +++++++++---------- ...generated_ldap_config_lifecycle_adapter.go | 9 +-- .../zz_generated_listen_config_controller.go | 65 +++++++++---------- ...nerated_listen_config_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_node_controller.go | 65 +++++++++---------- .../v3/zz_generated_node_driver_controller.go | 65 +++++++++---------- ...generated_node_driver_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_node_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_node_pool_controller.go | 65 +++++++++---------- ...z_generated_node_pool_lifecycle_adapter.go | 9 +-- .../zz_generated_node_template_controller.go | 65 +++++++++---------- ...nerated_node_template_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_notifier_controller.go | 65 +++++++++---------- ...zz_generated_notifier_lifecycle_adapter.go | 9 +-- ...pod_security_policy_template_controller.go | 65 +++++++++---------- ...urity_policy_template_lifecycle_adapter.go | 9 +-- ...icy_template_project_binding_controller.go | 65 +++++++++---------- ...plate_project_binding_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_preference_controller.go | 65 +++++++++---------- ..._generated_preference_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_principal_controller.go | 65 +++++++++---------- ...z_generated_principal_lifecycle_adapter.go | 9 +-- .../zz_generated_project_alert_controller.go | 65 +++++++++---------- ...nerated_project_alert_lifecycle_adapter.go | 9 +-- ...zz_generated_project_catalog_controller.go | 65 +++++++++---------- ...rated_project_catalog_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_project_controller.go | 65 +++++++++---------- .../zz_generated_project_lifecycle_adapter.go | 9 +-- ...zz_generated_project_logging_controller.go | 65 +++++++++---------- ...rated_project_logging_lifecycle_adapter.go | 9 +-- ...rated_project_network_policy_controller.go | 65 +++++++++---------- ...roject_network_policy_lifecycle_adapter.go | 9 +-- ...roject_role_template_binding_controller.go | 65 +++++++++---------- ...role_template_binding_lifecycle_adapter.go | 9 +-- .../zz_generated_role_template_controller.go | 65 +++++++++---------- ...nerated_role_template_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_setting_controller.go | 65 +++++++++---------- .../zz_generated_setting_lifecycle_adapter.go | 9 +-- ...z_generated_template_content_controller.go | 65 +++++++++---------- ...ated_template_content_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_template_controller.go | 65 +++++++++---------- ...zz_generated_template_lifecycle_adapter.go | 9 +-- ...z_generated_template_version_controller.go | 65 +++++++++---------- ...ated_template_version_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_token_controller.go | 65 +++++++++---------- .../zz_generated_token_lifecycle_adapter.go | 9 +-- .../zz_generated_user_attribute_controller.go | 65 +++++++++---------- ...erated_user_attribute_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_user_controller.go | 65 +++++++++---------- .../v3/zz_generated_user_lifecycle_adapter.go | 9 +-- .../zz_generated_auth_provider_controller.go | 65 +++++++++---------- ...nerated_auth_provider_lifecycle_adapter.go | 9 +-- .../zz_generated_network_policy_controller.go | 65 +++++++++---------- ...erated_network_policy_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_app_controller.go | 65 +++++++++---------- .../v3/zz_generated_app_lifecycle_adapter.go | 9 +-- .../zz_generated_app_revision_controller.go | 65 +++++++++---------- ...enerated_app_revision_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_basic_auth_controller.go | 65 +++++++++---------- ..._generated_basic_auth_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_certificate_controller.go | 65 +++++++++---------- ...generated_certificate_lifecycle_adapter.go | 9 +-- ..._generated_docker_credential_controller.go | 65 +++++++++---------- ...ted_docker_credential_lifecycle_adapter.go | 9 +-- ...erated_namespaced_basic_auth_controller.go | 65 +++++++++---------- ...namespaced_basic_auth_lifecycle_adapter.go | 9 +-- ...rated_namespaced_certificate_controller.go | 65 +++++++++---------- ...amespaced_certificate_lifecycle_adapter.go | 9 +-- ...namespaced_docker_credential_controller.go | 65 +++++++++---------- ...ced_docker_credential_lifecycle_adapter.go | 9 +-- ...spaced_service_account_token_controller.go | 65 +++++++++---------- ...service_account_token_lifecycle_adapter.go | 9 +-- ...enerated_namespaced_ssh_auth_controller.go | 65 +++++++++---------- ...d_namespaced_ssh_auth_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_pipeline_controller.go | 65 +++++++++---------- ...generated_pipeline_execution_controller.go | 65 +++++++++---------- ...ed_pipeline_execution_lifecycle_adapter.go | 9 +-- ...zz_generated_pipeline_lifecycle_adapter.go | 9 +-- ...z_generated_pipeline_setting_controller.go | 65 +++++++++---------- ...ated_pipeline_setting_lifecycle_adapter.go | 9 +-- ...erated_service_account_token_controller.go | 65 +++++++++---------- ...service_account_token_lifecycle_adapter.go | 9 +-- ...rated_source_code_credential_controller.go | 65 +++++++++---------- ...ource_code_credential_lifecycle_adapter.go | 9 +-- ..._source_code_provider_config_controller.go | 65 +++++++++---------- ..._code_provider_config_lifecycle_adapter.go | 9 +-- ...nerated_source_code_provider_controller.go | 65 +++++++++---------- ..._source_code_provider_lifecycle_adapter.go | 9 +-- ...rated_source_code_repository_controller.go | 65 +++++++++---------- ...ource_code_repository_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_ssh_auth_controller.go | 65 +++++++++---------- ...zz_generated_ssh_auth_lifecycle_adapter.go | 9 +-- .../v3/zz_generated_workload_controller.go | 65 +++++++++---------- ...zz_generated_workload_lifecycle_adapter.go | 9 +-- ...nerated_cluster_role_binding_controller.go | 65 +++++++++---------- ..._cluster_role_binding_lifecycle_adapter.go | 9 +-- .../zz_generated_cluster_role_controller.go | 65 +++++++++---------- ...enerated_cluster_role_lifecycle_adapter.go | 9 +-- .../zz_generated_role_binding_controller.go | 65 +++++++++---------- ...enerated_role_binding_lifecycle_adapter.go | 9 +-- .../v1/zz_generated_role_controller.go | 65 +++++++++---------- .../v1/zz_generated_role_lifecycle_adapter.go | 9 +-- 172 files changed, 2924 insertions(+), 3440 deletions(-) diff --git a/apis/apps/v1beta2/zz_generated_daemon_set_controller.go b/apis/apps/v1beta2/zz_generated_daemon_set_controller.go index aaf99e58..2e81b006 100644 --- a/apis/apps/v1beta2/zz_generated_daemon_set_controller.go +++ b/apis/apps/v1beta2/zz_generated_daemon_set_controller.go @@ -36,7 +36,7 @@ type DaemonSetList struct { Items []v1beta2.DaemonSet } -type DaemonSetHandlerFunc func(key string, obj *v1beta2.DaemonSet) error +type DaemonSetHandlerFunc func(key string, obj *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) type DaemonSetLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.DaemonSet, err error) @@ -47,8 +47,8 @@ type DaemonSetController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() DaemonSetLister - AddHandler(name string, handler DaemonSetHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler DaemonSetHandlerFunc) + AddHandler(ctx context.Context, name string, handler DaemonSetHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler DaemonSetHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type DaemonSetInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() DaemonSetController - AddHandler(name string, sync DaemonSetHandlerFunc) - AddLifecycle(name string, lifecycle DaemonSetLifecycle) - AddClusterScopedHandler(name, clusterName string, sync DaemonSetHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle DaemonSetLifecycle) + AddHandler(ctx context.Context, name string, sync DaemonSetHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle DaemonSetLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DaemonSetHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DaemonSetLifecycle) } type daemonSetLister struct { @@ -117,34 +117,27 @@ func (c *daemonSetController) Lister() DaemonSetLister { } } -func (c *daemonSetController) AddHandler(name string, handler DaemonSetHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *daemonSetController) AddHandler(ctx context.Context, name string, handler DaemonSetHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.DaemonSet); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta2.DaemonSet)) }) } -func (c *daemonSetController) AddClusterScopedHandler(name, cluster string, handler DaemonSetHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *daemonSetController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler DaemonSetHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.DaemonSet); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta2.DaemonSet)) }) } @@ -239,20 +232,20 @@ func (s *daemonSetClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, lis return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *daemonSetClient) AddHandler(name string, sync DaemonSetHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *daemonSetClient) AddHandler(ctx context.Context, name string, sync DaemonSetHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *daemonSetClient) AddLifecycle(name string, lifecycle DaemonSetLifecycle) { +func (s *daemonSetClient) AddLifecycle(ctx context.Context, name string, lifecycle DaemonSetLifecycle) { sync := NewDaemonSetLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *daemonSetClient) AddClusterScopedHandler(name, clusterName string, sync DaemonSetHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *daemonSetClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DaemonSetHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *daemonSetClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle DaemonSetLifecycle) { +func (s *daemonSetClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DaemonSetLifecycle) { sync := NewDaemonSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/apps/v1beta2/zz_generated_daemon_set_lifecycle_adapter.go b/apis/apps/v1beta2/zz_generated_daemon_set_lifecycle_adapter.go index ae5df964..0fcf8d46 100644 --- a/apis/apps/v1beta2/zz_generated_daemon_set_lifecycle_adapter.go +++ b/apis/apps/v1beta2/zz_generated_daemon_set_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *daemonSetLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewDaemonSetLifecycleAdapter(name string, clusterScoped bool, client DaemonSetInterface, l DaemonSetLifecycle) DaemonSetHandlerFunc { adapter := &daemonSetLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta2.DaemonSet) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta2.DaemonSet) (*v1beta2.DaemonSet, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta2.DaemonSet); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/apps/v1beta2/zz_generated_deployment_controller.go b/apis/apps/v1beta2/zz_generated_deployment_controller.go index 172fe536..b5b715eb 100644 --- a/apis/apps/v1beta2/zz_generated_deployment_controller.go +++ b/apis/apps/v1beta2/zz_generated_deployment_controller.go @@ -36,7 +36,7 @@ type DeploymentList struct { Items []v1beta2.Deployment } -type DeploymentHandlerFunc func(key string, obj *v1beta2.Deployment) error +type DeploymentHandlerFunc func(key string, obj *v1beta2.Deployment) (*v1beta2.Deployment, error) type DeploymentLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.Deployment, err error) @@ -47,8 +47,8 @@ type DeploymentController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() DeploymentLister - AddHandler(name string, handler DeploymentHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler DeploymentHandlerFunc) + AddHandler(ctx context.Context, name string, handler DeploymentHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler DeploymentHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type DeploymentInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() DeploymentController - AddHandler(name string, sync DeploymentHandlerFunc) - AddLifecycle(name string, lifecycle DeploymentLifecycle) - AddClusterScopedHandler(name, clusterName string, sync DeploymentHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle DeploymentLifecycle) + AddHandler(ctx context.Context, name string, sync DeploymentHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle DeploymentLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DeploymentHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DeploymentLifecycle) } type deploymentLister struct { @@ -117,34 +117,27 @@ func (c *deploymentController) Lister() DeploymentLister { } } -func (c *deploymentController) AddHandler(name string, handler DeploymentHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *deploymentController) AddHandler(ctx context.Context, name string, handler DeploymentHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.Deployment); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta2.Deployment)) }) } -func (c *deploymentController) AddClusterScopedHandler(name, cluster string, handler DeploymentHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *deploymentController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler DeploymentHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.Deployment); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta2.Deployment)) }) } @@ -239,20 +232,20 @@ func (s *deploymentClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *deploymentClient) AddHandler(name string, sync DeploymentHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *deploymentClient) AddHandler(ctx context.Context, name string, sync DeploymentHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *deploymentClient) AddLifecycle(name string, lifecycle DeploymentLifecycle) { +func (s *deploymentClient) AddLifecycle(ctx context.Context, name string, lifecycle DeploymentLifecycle) { sync := NewDeploymentLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *deploymentClient) AddClusterScopedHandler(name, clusterName string, sync DeploymentHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *deploymentClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DeploymentHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *deploymentClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle DeploymentLifecycle) { +func (s *deploymentClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DeploymentLifecycle) { sync := NewDeploymentLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/apps/v1beta2/zz_generated_deployment_lifecycle_adapter.go b/apis/apps/v1beta2/zz_generated_deployment_lifecycle_adapter.go index e282fb78..ebc036fa 100644 --- a/apis/apps/v1beta2/zz_generated_deployment_lifecycle_adapter.go +++ b/apis/apps/v1beta2/zz_generated_deployment_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *deploymentLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewDeploymentLifecycleAdapter(name string, clusterScoped bool, client DeploymentInterface, l DeploymentLifecycle) DeploymentHandlerFunc { adapter := &deploymentLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta2.Deployment) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta2.Deployment) (*v1beta2.Deployment, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta2.Deployment); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/apps/v1beta2/zz_generated_replica_set_controller.go b/apis/apps/v1beta2/zz_generated_replica_set_controller.go index 81aec2bf..c28dd7e4 100644 --- a/apis/apps/v1beta2/zz_generated_replica_set_controller.go +++ b/apis/apps/v1beta2/zz_generated_replica_set_controller.go @@ -36,7 +36,7 @@ type ReplicaSetList struct { Items []v1beta2.ReplicaSet } -type ReplicaSetHandlerFunc func(key string, obj *v1beta2.ReplicaSet) error +type ReplicaSetHandlerFunc func(key string, obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) type ReplicaSetLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.ReplicaSet, err error) @@ -47,8 +47,8 @@ type ReplicaSetController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ReplicaSetLister - AddHandler(name string, handler ReplicaSetHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ReplicaSetHandlerFunc) + AddHandler(ctx context.Context, name string, handler ReplicaSetHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ReplicaSetHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type ReplicaSetInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ReplicaSetController - AddHandler(name string, sync ReplicaSetHandlerFunc) - AddLifecycle(name string, lifecycle ReplicaSetLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ReplicaSetHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ReplicaSetLifecycle) + AddHandler(ctx context.Context, name string, sync ReplicaSetHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ReplicaSetLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ReplicaSetHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ReplicaSetLifecycle) } type replicaSetLister struct { @@ -117,34 +117,27 @@ func (c *replicaSetController) Lister() ReplicaSetLister { } } -func (c *replicaSetController) AddHandler(name string, handler ReplicaSetHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *replicaSetController) AddHandler(ctx context.Context, name string, handler ReplicaSetHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.ReplicaSet); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta2.ReplicaSet)) }) } -func (c *replicaSetController) AddClusterScopedHandler(name, cluster string, handler ReplicaSetHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *replicaSetController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ReplicaSetHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.ReplicaSet); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta2.ReplicaSet)) }) } @@ -239,20 +232,20 @@ func (s *replicaSetClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *replicaSetClient) AddHandler(name string, sync ReplicaSetHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *replicaSetClient) AddHandler(ctx context.Context, name string, sync ReplicaSetHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *replicaSetClient) AddLifecycle(name string, lifecycle ReplicaSetLifecycle) { +func (s *replicaSetClient) AddLifecycle(ctx context.Context, name string, lifecycle ReplicaSetLifecycle) { sync := NewReplicaSetLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *replicaSetClient) AddClusterScopedHandler(name, clusterName string, sync ReplicaSetHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *replicaSetClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ReplicaSetHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *replicaSetClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ReplicaSetLifecycle) { +func (s *replicaSetClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ReplicaSetLifecycle) { sync := NewReplicaSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/apps/v1beta2/zz_generated_replica_set_lifecycle_adapter.go b/apis/apps/v1beta2/zz_generated_replica_set_lifecycle_adapter.go index 851161e6..b7abe9b1 100644 --- a/apis/apps/v1beta2/zz_generated_replica_set_lifecycle_adapter.go +++ b/apis/apps/v1beta2/zz_generated_replica_set_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *replicaSetLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewReplicaSetLifecycleAdapter(name string, clusterScoped bool, client ReplicaSetInterface, l ReplicaSetLifecycle) ReplicaSetHandlerFunc { adapter := &replicaSetLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta2.ReplicaSet) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta2.ReplicaSet); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/apps/v1beta2/zz_generated_stateful_set_controller.go b/apis/apps/v1beta2/zz_generated_stateful_set_controller.go index 0c31b077..0ea6a596 100644 --- a/apis/apps/v1beta2/zz_generated_stateful_set_controller.go +++ b/apis/apps/v1beta2/zz_generated_stateful_set_controller.go @@ -36,7 +36,7 @@ type StatefulSetList struct { Items []v1beta2.StatefulSet } -type StatefulSetHandlerFunc func(key string, obj *v1beta2.StatefulSet) error +type StatefulSetHandlerFunc func(key string, obj *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) type StatefulSetLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta2.StatefulSet, err error) @@ -47,8 +47,8 @@ type StatefulSetController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() StatefulSetLister - AddHandler(name string, handler StatefulSetHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler StatefulSetHandlerFunc) + AddHandler(ctx context.Context, name string, handler StatefulSetHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler StatefulSetHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type StatefulSetInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() StatefulSetController - AddHandler(name string, sync StatefulSetHandlerFunc) - AddLifecycle(name string, lifecycle StatefulSetLifecycle) - AddClusterScopedHandler(name, clusterName string, sync StatefulSetHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle StatefulSetLifecycle) + AddHandler(ctx context.Context, name string, sync StatefulSetHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle StatefulSetLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync StatefulSetHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle StatefulSetLifecycle) } type statefulSetLister struct { @@ -117,34 +117,27 @@ func (c *statefulSetController) Lister() StatefulSetLister { } } -func (c *statefulSetController) AddHandler(name string, handler StatefulSetHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *statefulSetController) AddHandler(ctx context.Context, name string, handler StatefulSetHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.StatefulSet); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta2.StatefulSet)) }) } -func (c *statefulSetController) AddClusterScopedHandler(name, cluster string, handler StatefulSetHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *statefulSetController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler StatefulSetHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta2.StatefulSet); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta2.StatefulSet)) }) } @@ -239,20 +232,20 @@ func (s *statefulSetClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, l return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *statefulSetClient) AddHandler(name string, sync StatefulSetHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *statefulSetClient) AddHandler(ctx context.Context, name string, sync StatefulSetHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *statefulSetClient) AddLifecycle(name string, lifecycle StatefulSetLifecycle) { +func (s *statefulSetClient) AddLifecycle(ctx context.Context, name string, lifecycle StatefulSetLifecycle) { sync := NewStatefulSetLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *statefulSetClient) AddClusterScopedHandler(name, clusterName string, sync StatefulSetHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *statefulSetClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync StatefulSetHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *statefulSetClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle StatefulSetLifecycle) { +func (s *statefulSetClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle StatefulSetLifecycle) { sync := NewStatefulSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/apps/v1beta2/zz_generated_stateful_set_lifecycle_adapter.go b/apis/apps/v1beta2/zz_generated_stateful_set_lifecycle_adapter.go index 340e6977..12e84c2f 100644 --- a/apis/apps/v1beta2/zz_generated_stateful_set_lifecycle_adapter.go +++ b/apis/apps/v1beta2/zz_generated_stateful_set_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *statefulSetLifecycleAdapter) Updated(obj runtime.Object) (runtime.Objec func NewStatefulSetLifecycleAdapter(name string, clusterScoped bool, client StatefulSetInterface, l StatefulSetLifecycle) StatefulSetHandlerFunc { adapter := &statefulSetLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta2.StatefulSet) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta2.StatefulSet) (*v1beta2.StatefulSet, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta2.StatefulSet); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/batch/v1/zz_generated_job_controller.go b/apis/batch/v1/zz_generated_job_controller.go index 38d5f66a..6a296a1c 100644 --- a/apis/batch/v1/zz_generated_job_controller.go +++ b/apis/batch/v1/zz_generated_job_controller.go @@ -36,7 +36,7 @@ type JobList struct { Items []v1.Job } -type JobHandlerFunc func(key string, obj *v1.Job) error +type JobHandlerFunc func(key string, obj *v1.Job) (*v1.Job, error) type JobLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Job, err error) @@ -47,8 +47,8 @@ type JobController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() JobLister - AddHandler(name string, handler JobHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler JobHandlerFunc) + AddHandler(ctx context.Context, name string, handler JobHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler JobHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type JobInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() JobController - AddHandler(name string, sync JobHandlerFunc) - AddLifecycle(name string, lifecycle JobLifecycle) - AddClusterScopedHandler(name, clusterName string, sync JobHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle JobLifecycle) + AddHandler(ctx context.Context, name string, sync JobHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle JobLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync JobHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle JobLifecycle) } type jobLister struct { @@ -117,34 +117,27 @@ func (c *jobController) Lister() JobLister { } } -func (c *jobController) AddHandler(name string, handler JobHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *jobController) AddHandler(ctx context.Context, name string, handler JobHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Job); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Job)) }) } -func (c *jobController) AddClusterScopedHandler(name, cluster string, handler JobHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *jobController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler JobHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Job); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Job)) }) } @@ -239,20 +232,20 @@ func (s *jobClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *jobClient) AddHandler(name string, sync JobHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *jobClient) AddHandler(ctx context.Context, name string, sync JobHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *jobClient) AddLifecycle(name string, lifecycle JobLifecycle) { +func (s *jobClient) AddLifecycle(ctx context.Context, name string, lifecycle JobLifecycle) { sync := NewJobLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *jobClient) AddClusterScopedHandler(name, clusterName string, sync JobHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *jobClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync JobHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *jobClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle JobLifecycle) { +func (s *jobClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle JobLifecycle) { sync := NewJobLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/batch/v1/zz_generated_job_lifecycle_adapter.go b/apis/batch/v1/zz_generated_job_lifecycle_adapter.go index 5cd3ae82..126e1afd 100644 --- a/apis/batch/v1/zz_generated_job_lifecycle_adapter.go +++ b/apis/batch/v1/zz_generated_job_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *jobLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error func NewJobLifecycleAdapter(name string, clusterScoped bool, client JobInterface, l JobLifecycle) JobHandlerFunc { adapter := &jobLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Job) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Job) (*v1.Job, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Job); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/batch/v1beta1/zz_generated_cron_job_controller.go b/apis/batch/v1beta1/zz_generated_cron_job_controller.go index 0953a4e3..afd7d4d1 100644 --- a/apis/batch/v1beta1/zz_generated_cron_job_controller.go +++ b/apis/batch/v1beta1/zz_generated_cron_job_controller.go @@ -36,7 +36,7 @@ type CronJobList struct { Items []v1beta1.CronJob } -type CronJobHandlerFunc func(key string, obj *v1beta1.CronJob) error +type CronJobHandlerFunc func(key string, obj *v1beta1.CronJob) (*v1beta1.CronJob, error) type CronJobLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta1.CronJob, err error) @@ -47,8 +47,8 @@ type CronJobController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() CronJobLister - AddHandler(name string, handler CronJobHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler CronJobHandlerFunc) + AddHandler(ctx context.Context, name string, handler CronJobHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CronJobHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type CronJobInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() CronJobController - AddHandler(name string, sync CronJobHandlerFunc) - AddLifecycle(name string, lifecycle CronJobLifecycle) - AddClusterScopedHandler(name, clusterName string, sync CronJobHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle CronJobLifecycle) + AddHandler(ctx context.Context, name string, sync CronJobHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle CronJobLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CronJobHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CronJobLifecycle) } type cronJobLister struct { @@ -117,34 +117,27 @@ func (c *cronJobController) Lister() CronJobLister { } } -func (c *cronJobController) AddHandler(name string, handler CronJobHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *cronJobController) AddHandler(ctx context.Context, name string, handler CronJobHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta1.CronJob); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta1.CronJob)) }) } -func (c *cronJobController) AddClusterScopedHandler(name, cluster string, handler CronJobHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *cronJobController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler CronJobHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta1.CronJob); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta1.CronJob)) }) } @@ -239,20 +232,20 @@ func (s *cronJobClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *cronJobClient) AddHandler(name string, sync CronJobHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *cronJobClient) AddHandler(ctx context.Context, name string, sync CronJobHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *cronJobClient) AddLifecycle(name string, lifecycle CronJobLifecycle) { +func (s *cronJobClient) AddLifecycle(ctx context.Context, name string, lifecycle CronJobLifecycle) { sync := NewCronJobLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *cronJobClient) AddClusterScopedHandler(name, clusterName string, sync CronJobHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *cronJobClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CronJobHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *cronJobClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle CronJobLifecycle) { +func (s *cronJobClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CronJobLifecycle) { sync := NewCronJobLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/batch/v1beta1/zz_generated_cron_job_lifecycle_adapter.go b/apis/batch/v1beta1/zz_generated_cron_job_lifecycle_adapter.go index 6040ff84..851a43eb 100644 --- a/apis/batch/v1beta1/zz_generated_cron_job_lifecycle_adapter.go +++ b/apis/batch/v1beta1/zz_generated_cron_job_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *cronJobLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewCronJobLifecycleAdapter(name string, clusterScoped bool, client CronJobInterface, l CronJobLifecycle) CronJobHandlerFunc { adapter := &cronJobLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta1.CronJob) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta1.CronJob) (*v1beta1.CronJob, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta1.CronJob); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_component_status_controller.go b/apis/core/v1/zz_generated_component_status_controller.go index c16741aa..51668ba7 100644 --- a/apis/core/v1/zz_generated_component_status_controller.go +++ b/apis/core/v1/zz_generated_component_status_controller.go @@ -35,7 +35,7 @@ type ComponentStatusList struct { Items []v1.ComponentStatus } -type ComponentStatusHandlerFunc func(key string, obj *v1.ComponentStatus) error +type ComponentStatusHandlerFunc func(key string, obj *v1.ComponentStatus) (*v1.ComponentStatus, error) type ComponentStatusLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ComponentStatus, err error) @@ -46,8 +46,8 @@ type ComponentStatusController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ComponentStatusLister - AddHandler(name string, handler ComponentStatusHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ComponentStatusHandlerFunc) + AddHandler(ctx context.Context, name string, handler ComponentStatusHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ComponentStatusHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ComponentStatusInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ComponentStatusController - AddHandler(name string, sync ComponentStatusHandlerFunc) - AddLifecycle(name string, lifecycle ComponentStatusLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ComponentStatusHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ComponentStatusLifecycle) + AddHandler(ctx context.Context, name string, sync ComponentStatusHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ComponentStatusLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ComponentStatusHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ComponentStatusLifecycle) } type componentStatusLister struct { @@ -116,34 +116,27 @@ func (c *componentStatusController) Lister() ComponentStatusLister { } } -func (c *componentStatusController) AddHandler(name string, handler ComponentStatusHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *componentStatusController) AddHandler(ctx context.Context, name string, handler ComponentStatusHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ComponentStatus); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ComponentStatus)) }) } -func (c *componentStatusController) AddClusterScopedHandler(name, cluster string, handler ComponentStatusHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *componentStatusController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ComponentStatusHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ComponentStatus); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ComponentStatus)) }) } @@ -238,20 +231,20 @@ func (s *componentStatusClient) DeleteCollection(deleteOpts *metav1.DeleteOption return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *componentStatusClient) AddHandler(name string, sync ComponentStatusHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *componentStatusClient) AddHandler(ctx context.Context, name string, sync ComponentStatusHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *componentStatusClient) AddLifecycle(name string, lifecycle ComponentStatusLifecycle) { +func (s *componentStatusClient) AddLifecycle(ctx context.Context, name string, lifecycle ComponentStatusLifecycle) { sync := NewComponentStatusLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *componentStatusClient) AddClusterScopedHandler(name, clusterName string, sync ComponentStatusHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *componentStatusClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ComponentStatusHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *componentStatusClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ComponentStatusLifecycle) { +func (s *componentStatusClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ComponentStatusLifecycle) { sync := NewComponentStatusLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_component_status_lifecycle_adapter.go b/apis/core/v1/zz_generated_component_status_lifecycle_adapter.go index d4fb21c7..a62ff25a 100644 --- a/apis/core/v1/zz_generated_component_status_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_component_status_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *componentStatusLifecycleAdapter) Updated(obj runtime.Object) (runtime.O func NewComponentStatusLifecycleAdapter(name string, clusterScoped bool, client ComponentStatusInterface, l ComponentStatusLifecycle) ComponentStatusHandlerFunc { adapter := &componentStatusLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ComponentStatus) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ComponentStatus) (*v1.ComponentStatus, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ComponentStatus); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_config_map_controller.go b/apis/core/v1/zz_generated_config_map_controller.go index 71e3f102..0e790bb1 100644 --- a/apis/core/v1/zz_generated_config_map_controller.go +++ b/apis/core/v1/zz_generated_config_map_controller.go @@ -36,7 +36,7 @@ type ConfigMapList struct { Items []v1.ConfigMap } -type ConfigMapHandlerFunc func(key string, obj *v1.ConfigMap) error +type ConfigMapHandlerFunc func(key string, obj *v1.ConfigMap) (*v1.ConfigMap, error) type ConfigMapLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ConfigMap, err error) @@ -47,8 +47,8 @@ type ConfigMapController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ConfigMapLister - AddHandler(name string, handler ConfigMapHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ConfigMapHandlerFunc) + AddHandler(ctx context.Context, name string, handler ConfigMapHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ConfigMapHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type ConfigMapInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ConfigMapController - AddHandler(name string, sync ConfigMapHandlerFunc) - AddLifecycle(name string, lifecycle ConfigMapLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ConfigMapHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ConfigMapLifecycle) + AddHandler(ctx context.Context, name string, sync ConfigMapHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ConfigMapLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ConfigMapHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ConfigMapLifecycle) } type configMapLister struct { @@ -117,34 +117,27 @@ func (c *configMapController) Lister() ConfigMapLister { } } -func (c *configMapController) AddHandler(name string, handler ConfigMapHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *configMapController) AddHandler(ctx context.Context, name string, handler ConfigMapHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ConfigMap); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ConfigMap)) }) } -func (c *configMapController) AddClusterScopedHandler(name, cluster string, handler ConfigMapHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *configMapController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ConfigMapHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ConfigMap); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ConfigMap)) }) } @@ -239,20 +232,20 @@ func (s *configMapClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, lis return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *configMapClient) AddHandler(name string, sync ConfigMapHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *configMapClient) AddHandler(ctx context.Context, name string, sync ConfigMapHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *configMapClient) AddLifecycle(name string, lifecycle ConfigMapLifecycle) { +func (s *configMapClient) AddLifecycle(ctx context.Context, name string, lifecycle ConfigMapLifecycle) { sync := NewConfigMapLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *configMapClient) AddClusterScopedHandler(name, clusterName string, sync ConfigMapHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *configMapClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ConfigMapHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *configMapClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ConfigMapLifecycle) { +func (s *configMapClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ConfigMapLifecycle) { sync := NewConfigMapLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_config_map_lifecycle_adapter.go b/apis/core/v1/zz_generated_config_map_lifecycle_adapter.go index 0f73e083..f1128af3 100644 --- a/apis/core/v1/zz_generated_config_map_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_config_map_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *configMapLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewConfigMapLifecycleAdapter(name string, clusterScoped bool, client ConfigMapInterface, l ConfigMapLifecycle) ConfigMapHandlerFunc { adapter := &configMapLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ConfigMap) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ConfigMap) (*v1.ConfigMap, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ConfigMap); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_endpoints_controller.go b/apis/core/v1/zz_generated_endpoints_controller.go index 42a5730b..0040fd6e 100644 --- a/apis/core/v1/zz_generated_endpoints_controller.go +++ b/apis/core/v1/zz_generated_endpoints_controller.go @@ -36,7 +36,7 @@ type EndpointsList struct { Items []v1.Endpoints } -type EndpointsHandlerFunc func(key string, obj *v1.Endpoints) error +type EndpointsHandlerFunc func(key string, obj *v1.Endpoints) (*v1.Endpoints, error) type EndpointsLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Endpoints, err error) @@ -47,8 +47,8 @@ type EndpointsController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() EndpointsLister - AddHandler(name string, handler EndpointsHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler EndpointsHandlerFunc) + AddHandler(ctx context.Context, name string, handler EndpointsHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler EndpointsHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type EndpointsInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() EndpointsController - AddHandler(name string, sync EndpointsHandlerFunc) - AddLifecycle(name string, lifecycle EndpointsLifecycle) - AddClusterScopedHandler(name, clusterName string, sync EndpointsHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle EndpointsLifecycle) + AddHandler(ctx context.Context, name string, sync EndpointsHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle EndpointsLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync EndpointsHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle EndpointsLifecycle) } type endpointsLister struct { @@ -117,34 +117,27 @@ func (c *endpointsController) Lister() EndpointsLister { } } -func (c *endpointsController) AddHandler(name string, handler EndpointsHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *endpointsController) AddHandler(ctx context.Context, name string, handler EndpointsHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Endpoints); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Endpoints)) }) } -func (c *endpointsController) AddClusterScopedHandler(name, cluster string, handler EndpointsHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *endpointsController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler EndpointsHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Endpoints); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Endpoints)) }) } @@ -239,20 +232,20 @@ func (s *endpointsClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, lis return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *endpointsClient) AddHandler(name string, sync EndpointsHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *endpointsClient) AddHandler(ctx context.Context, name string, sync EndpointsHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *endpointsClient) AddLifecycle(name string, lifecycle EndpointsLifecycle) { +func (s *endpointsClient) AddLifecycle(ctx context.Context, name string, lifecycle EndpointsLifecycle) { sync := NewEndpointsLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *endpointsClient) AddClusterScopedHandler(name, clusterName string, sync EndpointsHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *endpointsClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync EndpointsHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *endpointsClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle EndpointsLifecycle) { +func (s *endpointsClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle EndpointsLifecycle) { sync := NewEndpointsLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_endpoints_lifecycle_adapter.go b/apis/core/v1/zz_generated_endpoints_lifecycle_adapter.go index 0eec2e55..36a5ccfb 100644 --- a/apis/core/v1/zz_generated_endpoints_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_endpoints_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *endpointsLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewEndpointsLifecycleAdapter(name string, clusterScoped bool, client EndpointsInterface, l EndpointsLifecycle) EndpointsHandlerFunc { adapter := &endpointsLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Endpoints) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Endpoints) (*v1.Endpoints, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Endpoints); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_event_controller.go b/apis/core/v1/zz_generated_event_controller.go index 83d2657c..8d582f97 100644 --- a/apis/core/v1/zz_generated_event_controller.go +++ b/apis/core/v1/zz_generated_event_controller.go @@ -35,7 +35,7 @@ type EventList struct { Items []v1.Event } -type EventHandlerFunc func(key string, obj *v1.Event) error +type EventHandlerFunc func(key string, obj *v1.Event) (*v1.Event, error) type EventLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Event, err error) @@ -46,8 +46,8 @@ type EventController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() EventLister - AddHandler(name string, handler EventHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler EventHandlerFunc) + AddHandler(ctx context.Context, name string, handler EventHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler EventHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type EventInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() EventController - AddHandler(name string, sync EventHandlerFunc) - AddLifecycle(name string, lifecycle EventLifecycle) - AddClusterScopedHandler(name, clusterName string, sync EventHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle EventLifecycle) + AddHandler(ctx context.Context, name string, sync EventHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle EventLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync EventHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle EventLifecycle) } type eventLister struct { @@ -116,34 +116,27 @@ func (c *eventController) Lister() EventLister { } } -func (c *eventController) AddHandler(name string, handler EventHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *eventController) AddHandler(ctx context.Context, name string, handler EventHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Event); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Event)) }) } -func (c *eventController) AddClusterScopedHandler(name, cluster string, handler EventHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *eventController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler EventHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Event); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Event)) }) } @@ -238,20 +231,20 @@ func (s *eventClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpt return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *eventClient) AddHandler(name string, sync EventHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *eventClient) AddHandler(ctx context.Context, name string, sync EventHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *eventClient) AddLifecycle(name string, lifecycle EventLifecycle) { +func (s *eventClient) AddLifecycle(ctx context.Context, name string, lifecycle EventLifecycle) { sync := NewEventLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *eventClient) AddClusterScopedHandler(name, clusterName string, sync EventHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *eventClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync EventHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *eventClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle EventLifecycle) { +func (s *eventClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle EventLifecycle) { sync := NewEventLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_event_lifecycle_adapter.go b/apis/core/v1/zz_generated_event_lifecycle_adapter.go index 67376ebf..b731eaf6 100644 --- a/apis/core/v1/zz_generated_event_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_event_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *eventLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, err func NewEventLifecycleAdapter(name string, clusterScoped bool, client EventInterface, l EventLifecycle) EventHandlerFunc { adapter := &eventLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Event) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Event) (*v1.Event, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Event); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_namespace_controller.go b/apis/core/v1/zz_generated_namespace_controller.go index 51b46da5..6b950cc3 100644 --- a/apis/core/v1/zz_generated_namespace_controller.go +++ b/apis/core/v1/zz_generated_namespace_controller.go @@ -35,7 +35,7 @@ type NamespaceList struct { Items []v1.Namespace } -type NamespaceHandlerFunc func(key string, obj *v1.Namespace) error +type NamespaceHandlerFunc func(key string, obj *v1.Namespace) (*v1.Namespace, error) type NamespaceLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Namespace, err error) @@ -46,8 +46,8 @@ type NamespaceController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NamespaceLister - AddHandler(name string, handler NamespaceHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespaceHandlerFunc) + AddHandler(ctx context.Context, name string, handler NamespaceHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NamespaceHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NamespaceInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NamespaceController - AddHandler(name string, sync NamespaceHandlerFunc) - AddLifecycle(name string, lifecycle NamespaceLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespaceHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespaceLifecycle) + AddHandler(ctx context.Context, name string, sync NamespaceHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NamespaceLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespaceHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespaceLifecycle) } type namespaceLister struct { @@ -116,34 +116,27 @@ func (c *namespaceController) Lister() NamespaceLister { } } -func (c *namespaceController) AddHandler(name string, handler NamespaceHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespaceController) AddHandler(ctx context.Context, name string, handler NamespaceHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Namespace); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Namespace)) }) } -func (c *namespaceController) AddClusterScopedHandler(name, cluster string, handler NamespaceHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespaceController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NamespaceHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Namespace); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Namespace)) }) } @@ -238,20 +231,20 @@ func (s *namespaceClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, lis return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *namespaceClient) AddHandler(name string, sync NamespaceHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *namespaceClient) AddHandler(ctx context.Context, name string, sync NamespaceHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespaceClient) AddLifecycle(name string, lifecycle NamespaceLifecycle) { +func (s *namespaceClient) AddLifecycle(ctx context.Context, name string, lifecycle NamespaceLifecycle) { sync := NewNamespaceLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespaceClient) AddClusterScopedHandler(name, clusterName string, sync NamespaceHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *namespaceClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespaceHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *namespaceClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespaceLifecycle) { +func (s *namespaceClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespaceLifecycle) { sync := NewNamespaceLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_namespace_lifecycle_adapter.go b/apis/core/v1/zz_generated_namespace_lifecycle_adapter.go index a9d54c49..5cba2d55 100644 --- a/apis/core/v1/zz_generated_namespace_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_namespace_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *namespaceLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewNamespaceLifecycleAdapter(name string, clusterScoped bool, client NamespaceInterface, l NamespaceLifecycle) NamespaceHandlerFunc { adapter := &namespaceLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Namespace) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Namespace) (*v1.Namespace, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Namespace); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_node_controller.go b/apis/core/v1/zz_generated_node_controller.go index 7e0d5f72..344f8afd 100644 --- a/apis/core/v1/zz_generated_node_controller.go +++ b/apis/core/v1/zz_generated_node_controller.go @@ -35,7 +35,7 @@ type NodeList struct { Items []v1.Node } -type NodeHandlerFunc func(key string, obj *v1.Node) error +type NodeHandlerFunc func(key string, obj *v1.Node) (*v1.Node, error) type NodeLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Node, err error) @@ -46,8 +46,8 @@ type NodeController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NodeLister - AddHandler(name string, handler NodeHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NodeHandlerFunc) + AddHandler(ctx context.Context, name string, handler NodeHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NodeInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NodeController - AddHandler(name string, sync NodeHandlerFunc) - AddLifecycle(name string, lifecycle NodeLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NodeHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeLifecycle) + AddHandler(ctx context.Context, name string, sync NodeHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NodeLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeLifecycle) } type nodeLister struct { @@ -116,34 +116,27 @@ func (c *nodeController) Lister() NodeLister { } } -func (c *nodeController) AddHandler(name string, handler NodeHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeController) AddHandler(ctx context.Context, name string, handler NodeHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Node); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Node)) }) } -func (c *nodeController) AddClusterScopedHandler(name, cluster string, handler NodeHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NodeHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Node); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Node)) }) } @@ -238,20 +231,20 @@ func (s *nodeClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *nodeClient) AddHandler(name string, sync NodeHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *nodeClient) AddHandler(ctx context.Context, name string, sync NodeHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeClient) AddLifecycle(name string, lifecycle NodeLifecycle) { +func (s *nodeClient) AddLifecycle(ctx context.Context, name string, lifecycle NodeLifecycle) { sync := NewNodeLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeClient) AddClusterScopedHandler(name, clusterName string, sync NodeHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *nodeClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *nodeClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeLifecycle) { +func (s *nodeClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeLifecycle) { sync := NewNodeLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_node_lifecycle_adapter.go b/apis/core/v1/zz_generated_node_lifecycle_adapter.go index 31beb32d..3721786b 100644 --- a/apis/core/v1/zz_generated_node_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_node_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *nodeLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, erro func NewNodeLifecycleAdapter(name string, clusterScoped bool, client NodeInterface, l NodeLifecycle) NodeHandlerFunc { adapter := &nodeLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Node) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Node) (*v1.Node, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Node); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 35c30974..701db7b3 100644 --- a/apis/core/v1/zz_generated_persistent_volume_claim_controller.go +++ b/apis/core/v1/zz_generated_persistent_volume_claim_controller.go @@ -36,7 +36,7 @@ type PersistentVolumeClaimList struct { Items []v1.PersistentVolumeClaim } -type PersistentVolumeClaimHandlerFunc func(key string, obj *v1.PersistentVolumeClaim) error +type PersistentVolumeClaimHandlerFunc func(key string, obj *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) type PersistentVolumeClaimLister interface { List(namespace string, selector labels.Selector) (ret []*v1.PersistentVolumeClaim, err error) @@ -47,8 +47,8 @@ type PersistentVolumeClaimController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PersistentVolumeClaimLister - AddHandler(name string, handler PersistentVolumeClaimHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PersistentVolumeClaimHandlerFunc) + AddHandler(ctx context.Context, name string, handler PersistentVolumeClaimHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PersistentVolumeClaimHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type PersistentVolumeClaimInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PersistentVolumeClaimController - AddHandler(name string, sync PersistentVolumeClaimHandlerFunc) - AddLifecycle(name string, lifecycle PersistentVolumeClaimLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PersistentVolumeClaimHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PersistentVolumeClaimLifecycle) + AddHandler(ctx context.Context, name string, sync PersistentVolumeClaimHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PersistentVolumeClaimLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PersistentVolumeClaimHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PersistentVolumeClaimLifecycle) } type persistentVolumeClaimLister struct { @@ -117,34 +117,27 @@ func (c *persistentVolumeClaimController) Lister() PersistentVolumeClaimLister { } } -func (c *persistentVolumeClaimController) AddHandler(name string, handler PersistentVolumeClaimHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *persistentVolumeClaimController) AddHandler(ctx context.Context, name string, handler PersistentVolumeClaimHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.PersistentVolumeClaim); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.PersistentVolumeClaim)) }) } -func (c *persistentVolumeClaimController) AddClusterScopedHandler(name, cluster string, handler PersistentVolumeClaimHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *persistentVolumeClaimController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PersistentVolumeClaimHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.PersistentVolumeClaim); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.PersistentVolumeClaim)) }) } @@ -239,20 +232,20 @@ func (s *persistentVolumeClaimClient) DeleteCollection(deleteOpts *metav1.Delete return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *persistentVolumeClaimClient) AddHandler(name string, sync PersistentVolumeClaimHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *persistentVolumeClaimClient) AddHandler(ctx context.Context, name string, sync PersistentVolumeClaimHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *persistentVolumeClaimClient) AddLifecycle(name string, lifecycle PersistentVolumeClaimLifecycle) { +func (s *persistentVolumeClaimClient) AddLifecycle(ctx context.Context, name string, lifecycle PersistentVolumeClaimLifecycle) { sync := NewPersistentVolumeClaimLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *persistentVolumeClaimClient) AddClusterScopedHandler(name, clusterName string, sync PersistentVolumeClaimHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *persistentVolumeClaimClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PersistentVolumeClaimHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *persistentVolumeClaimClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PersistentVolumeClaimLifecycle) { +func (s *persistentVolumeClaimClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PersistentVolumeClaimLifecycle) { sync := NewPersistentVolumeClaimLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_persistent_volume_claim_lifecycle_adapter.go b/apis/core/v1/zz_generated_persistent_volume_claim_lifecycle_adapter.go index f847c710..87a36a8e 100644 --- a/apis/core/v1/zz_generated_persistent_volume_claim_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_persistent_volume_claim_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *persistentVolumeClaimLifecycleAdapter) Updated(obj runtime.Object) (run func NewPersistentVolumeClaimLifecycleAdapter(name string, clusterScoped bool, client PersistentVolumeClaimInterface, l PersistentVolumeClaimLifecycle) PersistentVolumeClaimHandlerFunc { adapter := &persistentVolumeClaimLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.PersistentVolumeClaim) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.PersistentVolumeClaim); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_pod_controller.go b/apis/core/v1/zz_generated_pod_controller.go index 9e6372c9..90864d59 100644 --- a/apis/core/v1/zz_generated_pod_controller.go +++ b/apis/core/v1/zz_generated_pod_controller.go @@ -36,7 +36,7 @@ type PodList struct { Items []v1.Pod } -type PodHandlerFunc func(key string, obj *v1.Pod) error +type PodHandlerFunc func(key string, obj *v1.Pod) (*v1.Pod, error) type PodLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Pod, err error) @@ -47,8 +47,8 @@ type PodController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PodLister - AddHandler(name string, handler PodHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PodHandlerFunc) + AddHandler(ctx context.Context, name string, handler PodHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PodHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type PodInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PodController - AddHandler(name string, sync PodHandlerFunc) - AddLifecycle(name string, lifecycle PodLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PodHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PodLifecycle) + AddHandler(ctx context.Context, name string, sync PodHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PodLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodLifecycle) } type podLister struct { @@ -117,34 +117,27 @@ func (c *podController) Lister() PodLister { } } -func (c *podController) AddHandler(name string, handler PodHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podController) AddHandler(ctx context.Context, name string, handler PodHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Pod); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Pod)) }) } -func (c *podController) AddClusterScopedHandler(name, cluster string, handler PodHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PodHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Pod); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Pod)) }) } @@ -239,20 +232,20 @@ func (s *podClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *podClient) AddHandler(name string, sync PodHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *podClient) AddHandler(ctx context.Context, name string, sync PodHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *podClient) AddLifecycle(name string, lifecycle PodLifecycle) { +func (s *podClient) AddLifecycle(ctx context.Context, name string, lifecycle PodLifecycle) { sync := NewPodLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *podClient) AddClusterScopedHandler(name, clusterName string, sync PodHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *podClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *podClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PodLifecycle) { +func (s *podClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodLifecycle) { sync := NewPodLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_pod_lifecycle_adapter.go b/apis/core/v1/zz_generated_pod_lifecycle_adapter.go index cc228c1e..e33a309c 100644 --- a/apis/core/v1/zz_generated_pod_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_pod_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *podLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error func NewPodLifecycleAdapter(name string, clusterScoped bool, client PodInterface, l PodLifecycle) PodHandlerFunc { adapter := &podLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Pod) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Pod) (*v1.Pod, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Pod); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_replication_controller_controller.go b/apis/core/v1/zz_generated_replication_controller_controller.go index 903aad24..bd6bf088 100644 --- a/apis/core/v1/zz_generated_replication_controller_controller.go +++ b/apis/core/v1/zz_generated_replication_controller_controller.go @@ -36,7 +36,7 @@ type ReplicationControllerList struct { Items []v1.ReplicationController } -type ReplicationControllerHandlerFunc func(key string, obj *v1.ReplicationController) error +type ReplicationControllerHandlerFunc func(key string, obj *v1.ReplicationController) (*v1.ReplicationController, error) type ReplicationControllerLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ReplicationController, err error) @@ -47,8 +47,8 @@ type ReplicationControllerController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ReplicationControllerLister - AddHandler(name string, handler ReplicationControllerHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ReplicationControllerHandlerFunc) + AddHandler(ctx context.Context, name string, handler ReplicationControllerHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ReplicationControllerHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type ReplicationControllerInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ReplicationControllerController - AddHandler(name string, sync ReplicationControllerHandlerFunc) - AddLifecycle(name string, lifecycle ReplicationControllerLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ReplicationControllerHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ReplicationControllerLifecycle) + AddHandler(ctx context.Context, name string, sync ReplicationControllerHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ReplicationControllerLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ReplicationControllerHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ReplicationControllerLifecycle) } type replicationControllerLister struct { @@ -117,34 +117,27 @@ func (c *replicationControllerController) Lister() ReplicationControllerLister { } } -func (c *replicationControllerController) AddHandler(name string, handler ReplicationControllerHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *replicationControllerController) AddHandler(ctx context.Context, name string, handler ReplicationControllerHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ReplicationController); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ReplicationController)) }) } -func (c *replicationControllerController) AddClusterScopedHandler(name, cluster string, handler ReplicationControllerHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *replicationControllerController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ReplicationControllerHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ReplicationController); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ReplicationController)) }) } @@ -239,20 +232,20 @@ func (s *replicationControllerClient) DeleteCollection(deleteOpts *metav1.Delete return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *replicationControllerClient) AddHandler(name string, sync ReplicationControllerHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *replicationControllerClient) AddHandler(ctx context.Context, name string, sync ReplicationControllerHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *replicationControllerClient) AddLifecycle(name string, lifecycle ReplicationControllerLifecycle) { +func (s *replicationControllerClient) AddLifecycle(ctx context.Context, name string, lifecycle ReplicationControllerLifecycle) { sync := NewReplicationControllerLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *replicationControllerClient) AddClusterScopedHandler(name, clusterName string, sync ReplicationControllerHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *replicationControllerClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ReplicationControllerHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *replicationControllerClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ReplicationControllerLifecycle) { +func (s *replicationControllerClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ReplicationControllerLifecycle) { sync := NewReplicationControllerLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_replication_controller_lifecycle_adapter.go b/apis/core/v1/zz_generated_replication_controller_lifecycle_adapter.go index c3083a04..93ab56e5 100644 --- a/apis/core/v1/zz_generated_replication_controller_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_replication_controller_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *replicationControllerLifecycleAdapter) Updated(obj runtime.Object) (run func NewReplicationControllerLifecycleAdapter(name string, clusterScoped bool, client ReplicationControllerInterface, l ReplicationControllerLifecycle) ReplicationControllerHandlerFunc { adapter := &replicationControllerLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ReplicationController) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ReplicationController) (*v1.ReplicationController, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ReplicationController); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_resource_quota_controller.go b/apis/core/v1/zz_generated_resource_quota_controller.go index 5c35aed4..edcb4418 100644 --- a/apis/core/v1/zz_generated_resource_quota_controller.go +++ b/apis/core/v1/zz_generated_resource_quota_controller.go @@ -36,7 +36,7 @@ type ResourceQuotaList struct { Items []v1.ResourceQuota } -type ResourceQuotaHandlerFunc func(key string, obj *v1.ResourceQuota) error +type ResourceQuotaHandlerFunc func(key string, obj *v1.ResourceQuota) (*v1.ResourceQuota, error) type ResourceQuotaLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ResourceQuota, err error) @@ -47,8 +47,8 @@ type ResourceQuotaController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ResourceQuotaLister - AddHandler(name string, handler ResourceQuotaHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ResourceQuotaHandlerFunc) + AddHandler(ctx context.Context, name string, handler ResourceQuotaHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ResourceQuotaHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type ResourceQuotaInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ResourceQuotaController - AddHandler(name string, sync ResourceQuotaHandlerFunc) - AddLifecycle(name string, lifecycle ResourceQuotaLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ResourceQuotaHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ResourceQuotaLifecycle) + AddHandler(ctx context.Context, name string, sync ResourceQuotaHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ResourceQuotaLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ResourceQuotaHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ResourceQuotaLifecycle) } type resourceQuotaLister struct { @@ -117,34 +117,27 @@ func (c *resourceQuotaController) Lister() ResourceQuotaLister { } } -func (c *resourceQuotaController) AddHandler(name string, handler ResourceQuotaHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *resourceQuotaController) AddHandler(ctx context.Context, name string, handler ResourceQuotaHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ResourceQuota); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ResourceQuota)) }) } -func (c *resourceQuotaController) AddClusterScopedHandler(name, cluster string, handler ResourceQuotaHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *resourceQuotaController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ResourceQuotaHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ResourceQuota); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ResourceQuota)) }) } @@ -239,20 +232,20 @@ func (s *resourceQuotaClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *resourceQuotaClient) AddHandler(name string, sync ResourceQuotaHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *resourceQuotaClient) AddHandler(ctx context.Context, name string, sync ResourceQuotaHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *resourceQuotaClient) AddLifecycle(name string, lifecycle ResourceQuotaLifecycle) { +func (s *resourceQuotaClient) AddLifecycle(ctx context.Context, name string, lifecycle ResourceQuotaLifecycle) { sync := NewResourceQuotaLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *resourceQuotaClient) AddClusterScopedHandler(name, clusterName string, sync ResourceQuotaHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *resourceQuotaClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ResourceQuotaHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *resourceQuotaClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ResourceQuotaLifecycle) { +func (s *resourceQuotaClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ResourceQuotaLifecycle) { sync := NewResourceQuotaLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_resource_quota_lifecycle_adapter.go b/apis/core/v1/zz_generated_resource_quota_lifecycle_adapter.go index 2af628ff..a2bfe7f1 100644 --- a/apis/core/v1/zz_generated_resource_quota_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_resource_quota_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *resourceQuotaLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obj func NewResourceQuotaLifecycleAdapter(name string, clusterScoped bool, client ResourceQuotaInterface, l ResourceQuotaLifecycle) ResourceQuotaHandlerFunc { adapter := &resourceQuotaLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ResourceQuota) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ResourceQuota) (*v1.ResourceQuota, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ResourceQuota); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_secret_controller.go b/apis/core/v1/zz_generated_secret_controller.go index 3fbd2aed..accb45b4 100644 --- a/apis/core/v1/zz_generated_secret_controller.go +++ b/apis/core/v1/zz_generated_secret_controller.go @@ -36,7 +36,7 @@ type SecretList struct { Items []v1.Secret } -type SecretHandlerFunc func(key string, obj *v1.Secret) error +type SecretHandlerFunc func(key string, obj *v1.Secret) (*v1.Secret, error) type SecretLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Secret, err error) @@ -47,8 +47,8 @@ type SecretController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SecretLister - AddHandler(name string, handler SecretHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SecretHandlerFunc) + AddHandler(ctx context.Context, name string, handler SecretHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SecretHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type SecretInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SecretController - AddHandler(name string, sync SecretHandlerFunc) - AddLifecycle(name string, lifecycle SecretLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SecretHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SecretLifecycle) + AddHandler(ctx context.Context, name string, sync SecretHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SecretLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SecretHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SecretLifecycle) } type secretLister struct { @@ -117,34 +117,27 @@ func (c *secretController) Lister() SecretLister { } } -func (c *secretController) AddHandler(name string, handler SecretHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *secretController) AddHandler(ctx context.Context, name string, handler SecretHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Secret); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Secret)) }) } -func (c *secretController) AddClusterScopedHandler(name, cluster string, handler SecretHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *secretController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SecretHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Secret); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Secret)) }) } @@ -239,20 +232,20 @@ func (s *secretClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOp return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *secretClient) AddHandler(name string, sync SecretHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *secretClient) AddHandler(ctx context.Context, name string, sync SecretHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *secretClient) AddLifecycle(name string, lifecycle SecretLifecycle) { +func (s *secretClient) AddLifecycle(ctx context.Context, name string, lifecycle SecretLifecycle) { sync := NewSecretLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *secretClient) AddClusterScopedHandler(name, clusterName string, sync SecretHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *secretClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SecretHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *secretClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SecretLifecycle) { +func (s *secretClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SecretLifecycle) { sync := NewSecretLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_secret_lifecycle_adapter.go b/apis/core/v1/zz_generated_secret_lifecycle_adapter.go index 5bcea388..2eac50b6 100644 --- a/apis/core/v1/zz_generated_secret_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_secret_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *secretLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, er func NewSecretLifecycleAdapter(name string, clusterScoped bool, client SecretInterface, l SecretLifecycle) SecretHandlerFunc { adapter := &secretLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Secret) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Secret) (*v1.Secret, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Secret); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_service_account_controller.go b/apis/core/v1/zz_generated_service_account_controller.go index e4f2cd57..92f5fe32 100644 --- a/apis/core/v1/zz_generated_service_account_controller.go +++ b/apis/core/v1/zz_generated_service_account_controller.go @@ -36,7 +36,7 @@ type ServiceAccountList struct { Items []v1.ServiceAccount } -type ServiceAccountHandlerFunc func(key string, obj *v1.ServiceAccount) error +type ServiceAccountHandlerFunc func(key string, obj *v1.ServiceAccount) (*v1.ServiceAccount, error) type ServiceAccountLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ServiceAccount, err error) @@ -47,8 +47,8 @@ type ServiceAccountController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ServiceAccountLister - AddHandler(name string, handler ServiceAccountHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ServiceAccountHandlerFunc) + AddHandler(ctx context.Context, name string, handler ServiceAccountHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ServiceAccountHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type ServiceAccountInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ServiceAccountController - AddHandler(name string, sync ServiceAccountHandlerFunc) - AddLifecycle(name string, lifecycle ServiceAccountLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ServiceAccountHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ServiceAccountLifecycle) + AddHandler(ctx context.Context, name string, sync ServiceAccountHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ServiceAccountLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceAccountHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceAccountLifecycle) } type serviceAccountLister struct { @@ -117,34 +117,27 @@ func (c *serviceAccountController) Lister() ServiceAccountLister { } } -func (c *serviceAccountController) AddHandler(name string, handler ServiceAccountHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *serviceAccountController) AddHandler(ctx context.Context, name string, handler ServiceAccountHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ServiceAccount); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ServiceAccount)) }) } -func (c *serviceAccountController) AddClusterScopedHandler(name, cluster string, handler ServiceAccountHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *serviceAccountController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ServiceAccountHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ServiceAccount); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ServiceAccount)) }) } @@ -239,20 +232,20 @@ func (s *serviceAccountClient) DeleteCollection(deleteOpts *metav1.DeleteOptions return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *serviceAccountClient) AddHandler(name string, sync ServiceAccountHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *serviceAccountClient) AddHandler(ctx context.Context, name string, sync ServiceAccountHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *serviceAccountClient) AddLifecycle(name string, lifecycle ServiceAccountLifecycle) { +func (s *serviceAccountClient) AddLifecycle(ctx context.Context, name string, lifecycle ServiceAccountLifecycle) { sync := NewServiceAccountLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *serviceAccountClient) AddClusterScopedHandler(name, clusterName string, sync ServiceAccountHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *serviceAccountClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceAccountHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *serviceAccountClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ServiceAccountLifecycle) { +func (s *serviceAccountClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceAccountLifecycle) { sync := NewServiceAccountLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_service_account_lifecycle_adapter.go b/apis/core/v1/zz_generated_service_account_lifecycle_adapter.go index a9bb01df..bd768dfe 100644 --- a/apis/core/v1/zz_generated_service_account_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_service_account_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *serviceAccountLifecycleAdapter) Updated(obj runtime.Object) (runtime.Ob func NewServiceAccountLifecycleAdapter(name string, clusterScoped bool, client ServiceAccountInterface, l ServiceAccountLifecycle) ServiceAccountHandlerFunc { adapter := &serviceAccountLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ServiceAccount) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ServiceAccount) (*v1.ServiceAccount, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ServiceAccount); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/core/v1/zz_generated_service_controller.go b/apis/core/v1/zz_generated_service_controller.go index ca8d5975..1df2342f 100644 --- a/apis/core/v1/zz_generated_service_controller.go +++ b/apis/core/v1/zz_generated_service_controller.go @@ -36,7 +36,7 @@ type ServiceList struct { Items []v1.Service } -type ServiceHandlerFunc func(key string, obj *v1.Service) error +type ServiceHandlerFunc func(key string, obj *v1.Service) (*v1.Service, error) type ServiceLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Service, err error) @@ -47,8 +47,8 @@ type ServiceController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ServiceLister - AddHandler(name string, handler ServiceHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ServiceHandlerFunc) + AddHandler(ctx context.Context, name string, handler ServiceHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ServiceHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type ServiceInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ServiceController - AddHandler(name string, sync ServiceHandlerFunc) - AddLifecycle(name string, lifecycle ServiceLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ServiceHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ServiceLifecycle) + AddHandler(ctx context.Context, name string, sync ServiceHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ServiceLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceLifecycle) } type serviceLister struct { @@ -117,34 +117,27 @@ func (c *serviceController) Lister() ServiceLister { } } -func (c *serviceController) AddHandler(name string, handler ServiceHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *serviceController) AddHandler(ctx context.Context, name string, handler ServiceHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Service); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Service)) }) } -func (c *serviceController) AddClusterScopedHandler(name, cluster string, handler ServiceHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *serviceController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ServiceHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Service); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Service)) }) } @@ -239,20 +232,20 @@ func (s *serviceClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *serviceClient) AddHandler(name string, sync ServiceHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *serviceClient) AddHandler(ctx context.Context, name string, sync ServiceHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *serviceClient) AddLifecycle(name string, lifecycle ServiceLifecycle) { +func (s *serviceClient) AddLifecycle(ctx context.Context, name string, lifecycle ServiceLifecycle) { sync := NewServiceLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *serviceClient) AddClusterScopedHandler(name, clusterName string, sync ServiceHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *serviceClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *serviceClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ServiceLifecycle) { +func (s *serviceClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceLifecycle) { sync := NewServiceLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/core/v1/zz_generated_service_lifecycle_adapter.go b/apis/core/v1/zz_generated_service_lifecycle_adapter.go index ce19c58e..65380e31 100644 --- a/apis/core/v1/zz_generated_service_lifecycle_adapter.go +++ b/apis/core/v1/zz_generated_service_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *serviceLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewServiceLifecycleAdapter(name string, clusterScoped bool, client ServiceInterface, l ServiceLifecycle) ServiceHandlerFunc { adapter := &serviceLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Service) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Service) (*v1.Service, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Service); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/extensions/v1beta1/zz_generated_ingress_controller.go b/apis/extensions/v1beta1/zz_generated_ingress_controller.go index 44cf28e9..3e307ddf 100644 --- a/apis/extensions/v1beta1/zz_generated_ingress_controller.go +++ b/apis/extensions/v1beta1/zz_generated_ingress_controller.go @@ -36,7 +36,7 @@ type IngressList struct { Items []v1beta1.Ingress } -type IngressHandlerFunc func(key string, obj *v1beta1.Ingress) error +type IngressHandlerFunc func(key string, obj *v1beta1.Ingress) (*v1beta1.Ingress, error) type IngressLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta1.Ingress, err error) @@ -47,8 +47,8 @@ type IngressController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() IngressLister - AddHandler(name string, handler IngressHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler IngressHandlerFunc) + AddHandler(ctx context.Context, name string, handler IngressHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler IngressHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type IngressInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() IngressController - AddHandler(name string, sync IngressHandlerFunc) - AddLifecycle(name string, lifecycle IngressLifecycle) - AddClusterScopedHandler(name, clusterName string, sync IngressHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle IngressLifecycle) + AddHandler(ctx context.Context, name string, sync IngressHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle IngressLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync IngressHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle IngressLifecycle) } type ingressLister struct { @@ -117,34 +117,27 @@ func (c *ingressController) Lister() IngressLister { } } -func (c *ingressController) AddHandler(name string, handler IngressHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *ingressController) AddHandler(ctx context.Context, name string, handler IngressHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta1.Ingress); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta1.Ingress)) }) } -func (c *ingressController) AddClusterScopedHandler(name, cluster string, handler IngressHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *ingressController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler IngressHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta1.Ingress); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta1.Ingress)) }) } @@ -239,20 +232,20 @@ func (s *ingressClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *ingressClient) AddHandler(name string, sync IngressHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *ingressClient) AddHandler(ctx context.Context, name string, sync IngressHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *ingressClient) AddLifecycle(name string, lifecycle IngressLifecycle) { +func (s *ingressClient) AddLifecycle(ctx context.Context, name string, lifecycle IngressLifecycle) { sync := NewIngressLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *ingressClient) AddClusterScopedHandler(name, clusterName string, sync IngressHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *ingressClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync IngressHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *ingressClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle IngressLifecycle) { +func (s *ingressClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle IngressLifecycle) { sync := NewIngressLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/extensions/v1beta1/zz_generated_ingress_lifecycle_adapter.go b/apis/extensions/v1beta1/zz_generated_ingress_lifecycle_adapter.go index d3c70f6b..acabe71e 100644 --- a/apis/extensions/v1beta1/zz_generated_ingress_lifecycle_adapter.go +++ b/apis/extensions/v1beta1/zz_generated_ingress_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *ingressLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewIngressLifecycleAdapter(name string, clusterScoped bool, client IngressInterface, l IngressLifecycle) IngressHandlerFunc { adapter := &ingressLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta1.Ingress) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta1.Ingress) (*v1beta1.Ingress, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta1.Ingress); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 6627c26d..a440ac24 100644 --- a/apis/extensions/v1beta1/zz_generated_pod_security_policy_controller.go +++ b/apis/extensions/v1beta1/zz_generated_pod_security_policy_controller.go @@ -35,7 +35,7 @@ type PodSecurityPolicyList struct { Items []v1beta1.PodSecurityPolicy } -type PodSecurityPolicyHandlerFunc func(key string, obj *v1beta1.PodSecurityPolicy) error +type PodSecurityPolicyHandlerFunc func(key string, obj *v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error) type PodSecurityPolicyLister interface { List(namespace string, selector labels.Selector) (ret []*v1beta1.PodSecurityPolicy, err error) @@ -46,8 +46,8 @@ type PodSecurityPolicyController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PodSecurityPolicyLister - AddHandler(name string, handler PodSecurityPolicyHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PodSecurityPolicyHandlerFunc) + AddHandler(ctx context.Context, name string, handler PodSecurityPolicyHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PodSecurityPolicyHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type PodSecurityPolicyInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PodSecurityPolicyController - AddHandler(name string, sync PodSecurityPolicyHandlerFunc) - AddLifecycle(name string, lifecycle PodSecurityPolicyLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PodSecurityPolicyHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PodSecurityPolicyLifecycle) + AddHandler(ctx context.Context, name string, sync PodSecurityPolicyHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyLifecycle) } type podSecurityPolicyLister struct { @@ -116,34 +116,27 @@ func (c *podSecurityPolicyController) Lister() PodSecurityPolicyLister { } } -func (c *podSecurityPolicyController) AddHandler(name string, handler PodSecurityPolicyHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podSecurityPolicyController) AddHandler(ctx context.Context, name string, handler PodSecurityPolicyHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta1.PodSecurityPolicy); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1beta1.PodSecurityPolicy)) }) } -func (c *podSecurityPolicyController) AddClusterScopedHandler(name, cluster string, handler PodSecurityPolicyHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podSecurityPolicyController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PodSecurityPolicyHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1beta1.PodSecurityPolicy); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1beta1.PodSecurityPolicy)) }) } @@ -238,20 +231,20 @@ func (s *podSecurityPolicyClient) DeleteCollection(deleteOpts *metav1.DeleteOpti return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *podSecurityPolicyClient) AddHandler(name string, sync PodSecurityPolicyHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *podSecurityPolicyClient) AddHandler(ctx context.Context, name string, sync PodSecurityPolicyHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *podSecurityPolicyClient) AddLifecycle(name string, lifecycle PodSecurityPolicyLifecycle) { +func (s *podSecurityPolicyClient) AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyLifecycle) { sync := NewPodSecurityPolicyLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *podSecurityPolicyClient) AddClusterScopedHandler(name, clusterName string, sync PodSecurityPolicyHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *podSecurityPolicyClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *podSecurityPolicyClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PodSecurityPolicyLifecycle) { +func (s *podSecurityPolicyClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyLifecycle) { sync := NewPodSecurityPolicyLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/extensions/v1beta1/zz_generated_pod_security_policy_lifecycle_adapter.go b/apis/extensions/v1beta1/zz_generated_pod_security_policy_lifecycle_adapter.go index 855edbef..84ea3e6a 100644 --- a/apis/extensions/v1beta1/zz_generated_pod_security_policy_lifecycle_adapter.go +++ b/apis/extensions/v1beta1/zz_generated_pod_security_policy_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *podSecurityPolicyLifecycleAdapter) Updated(obj runtime.Object) (runtime func NewPodSecurityPolicyLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyInterface, l PodSecurityPolicyLifecycle) PodSecurityPolicyHandlerFunc { adapter := &podSecurityPolicyLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1beta1.PodSecurityPolicy) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1beta1.PodSecurityPolicy); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 c136bb45..26697608 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 @@ -34,7 +34,7 @@ type AuthConfigList struct { Items []AuthConfig } -type AuthConfigHandlerFunc func(key string, obj *AuthConfig) error +type AuthConfigHandlerFunc func(key string, obj *AuthConfig) (*AuthConfig, error) type AuthConfigLister interface { List(namespace string, selector labels.Selector) (ret []*AuthConfig, err error) @@ -45,8 +45,8 @@ type AuthConfigController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() AuthConfigLister - AddHandler(name string, handler AuthConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler AuthConfigHandlerFunc) + AddHandler(ctx context.Context, name string, handler AuthConfigHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler AuthConfigHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type AuthConfigInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() AuthConfigController - AddHandler(name string, sync AuthConfigHandlerFunc) - AddLifecycle(name string, lifecycle AuthConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync AuthConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle AuthConfigLifecycle) + AddHandler(ctx context.Context, name string, sync AuthConfigHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle AuthConfigLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AuthConfigHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AuthConfigLifecycle) } type authConfigLister struct { @@ -115,34 +115,27 @@ func (c *authConfigController) Lister() AuthConfigLister { } } -func (c *authConfigController) AddHandler(name string, handler AuthConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *authConfigController) AddHandler(ctx context.Context, name string, handler AuthConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*AuthConfig); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*AuthConfig)) }) } -func (c *authConfigController) AddClusterScopedHandler(name, cluster string, handler AuthConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *authConfigController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler AuthConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*AuthConfig); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*AuthConfig)) }) } @@ -237,20 +230,20 @@ func (s *authConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *authConfigClient) AddHandler(name string, sync AuthConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *authConfigClient) AddHandler(ctx context.Context, name string, sync AuthConfigHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *authConfigClient) AddLifecycle(name string, lifecycle AuthConfigLifecycle) { +func (s *authConfigClient) AddLifecycle(ctx context.Context, name string, lifecycle AuthConfigLifecycle) { sync := NewAuthConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *authConfigClient) AddClusterScopedHandler(name, clusterName string, sync AuthConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *authConfigClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AuthConfigHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *authConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle AuthConfigLifecycle) { +func (s *authConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AuthConfigLifecycle) { sync := NewAuthConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_auth_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_auth_config_lifecycle_adapter.go index 5dd96418..d9222500 100644 --- a/apis/management.cattle.io/v3/zz_generated_auth_config_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_auth_config_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *authConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewAuthConfigLifecycleAdapter(name string, clusterScoped bool, client AuthConfigInterface, l AuthConfigLifecycle) AuthConfigHandlerFunc { adapter := &authConfigLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *AuthConfig) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *AuthConfig) (*AuthConfig, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*AuthConfig); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 3c7e594f..2f04ceb2 100644 --- a/apis/management.cattle.io/v3/zz_generated_catalog_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_catalog_controller.go @@ -34,7 +34,7 @@ type CatalogList struct { Items []Catalog } -type CatalogHandlerFunc func(key string, obj *Catalog) error +type CatalogHandlerFunc func(key string, obj *Catalog) (*Catalog, error) type CatalogLister interface { List(namespace string, selector labels.Selector) (ret []*Catalog, err error) @@ -45,8 +45,8 @@ type CatalogController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() CatalogLister - AddHandler(name string, handler CatalogHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler CatalogHandlerFunc) + AddHandler(ctx context.Context, name string, handler CatalogHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CatalogHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type CatalogInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() CatalogController - AddHandler(name string, sync CatalogHandlerFunc) - AddLifecycle(name string, lifecycle CatalogLifecycle) - AddClusterScopedHandler(name, clusterName string, sync CatalogHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle CatalogLifecycle) + AddHandler(ctx context.Context, name string, sync CatalogHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle CatalogLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CatalogHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CatalogLifecycle) } type catalogLister struct { @@ -115,34 +115,27 @@ func (c *catalogController) Lister() CatalogLister { } } -func (c *catalogController) AddHandler(name string, handler CatalogHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *catalogController) AddHandler(ctx context.Context, name string, handler CatalogHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Catalog); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Catalog)) }) } -func (c *catalogController) AddClusterScopedHandler(name, cluster string, handler CatalogHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *catalogController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler CatalogHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Catalog); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Catalog)) }) } @@ -237,20 +230,20 @@ func (s *catalogClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *catalogClient) AddHandler(name string, sync CatalogHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *catalogClient) AddHandler(ctx context.Context, name string, sync CatalogHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *catalogClient) AddLifecycle(name string, lifecycle CatalogLifecycle) { +func (s *catalogClient) AddLifecycle(ctx context.Context, name string, lifecycle CatalogLifecycle) { sync := NewCatalogLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *catalogClient) AddClusterScopedHandler(name, clusterName string, sync CatalogHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *catalogClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CatalogHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *catalogClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle CatalogLifecycle) { +func (s *catalogClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CatalogLifecycle) { sync := NewCatalogLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_catalog_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_catalog_lifecycle_adapter.go index be7be01d..336aba97 100644 --- a/apis/management.cattle.io/v3/zz_generated_catalog_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_catalog_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *catalogLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewCatalogLifecycleAdapter(name string, clusterScoped bool, client CatalogInterface, l CatalogLifecycle) CatalogHandlerFunc { adapter := &catalogLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Catalog) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Catalog) (*Catalog, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Catalog); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 1c9b2d33..552ade53 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 @@ -35,7 +35,7 @@ type ClusterAlertList struct { Items []ClusterAlert } -type ClusterAlertHandlerFunc func(key string, obj *ClusterAlert) error +type ClusterAlertHandlerFunc func(key string, obj *ClusterAlert) (*ClusterAlert, error) type ClusterAlertLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterAlert, err error) @@ -46,8 +46,8 @@ type ClusterAlertController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterAlertLister - AddHandler(name string, handler ClusterAlertHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterAlertHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterAlertHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterAlertHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterAlertInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterAlertController - AddHandler(name string, sync ClusterAlertHandlerFunc) - AddLifecycle(name string, lifecycle ClusterAlertLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterAlertHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterAlertLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterAlertHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterAlertLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterAlertHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterAlertLifecycle) } type clusterAlertLister struct { @@ -116,34 +116,27 @@ func (c *clusterAlertController) Lister() ClusterAlertLister { } } -func (c *clusterAlertController) AddHandler(name string, handler ClusterAlertHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterAlertController) AddHandler(ctx context.Context, name string, handler ClusterAlertHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterAlert); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ClusterAlert)) }) } -func (c *clusterAlertController) AddClusterScopedHandler(name, cluster string, handler ClusterAlertHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterAlertController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterAlertHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterAlert); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ClusterAlert)) }) } @@ -238,20 +231,20 @@ func (s *clusterAlertClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterAlertClient) AddHandler(name string, sync ClusterAlertHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterAlertClient) AddHandler(ctx context.Context, name string, sync ClusterAlertHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterAlertClient) AddLifecycle(name string, lifecycle ClusterAlertLifecycle) { +func (s *clusterAlertClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterAlertLifecycle) { sync := NewClusterAlertLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterAlertClient) AddClusterScopedHandler(name, clusterName string, sync ClusterAlertHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterAlertClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterAlertHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterAlertClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterAlertLifecycle) { +func (s *clusterAlertClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterAlertLifecycle) { sync := NewClusterAlertLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_alert_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_alert_lifecycle_adapter.go index 4d44fb31..98a9810c 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_alert_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_alert_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *clusterAlertLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obje func NewClusterAlertLifecycleAdapter(name string, clusterScoped bool, client ClusterAlertInterface, l ClusterAlertLifecycle) ClusterAlertHandlerFunc { adapter := &clusterAlertLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ClusterAlert) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ClusterAlert) (*ClusterAlert, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ClusterAlert); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 ce0df92e..59bb8db4 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 @@ -35,7 +35,7 @@ type ClusterCatalogList struct { Items []ClusterCatalog } -type ClusterCatalogHandlerFunc func(key string, obj *ClusterCatalog) error +type ClusterCatalogHandlerFunc func(key string, obj *ClusterCatalog) (*ClusterCatalog, error) type ClusterCatalogLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterCatalog, err error) @@ -46,8 +46,8 @@ type ClusterCatalogController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterCatalogLister - AddHandler(name string, handler ClusterCatalogHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterCatalogHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterCatalogHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterCatalogHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterCatalogInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterCatalogController - AddHandler(name string, sync ClusterCatalogHandlerFunc) - AddLifecycle(name string, lifecycle ClusterCatalogLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterCatalogHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterCatalogLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterCatalogHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterCatalogLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterCatalogHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterCatalogLifecycle) } type clusterCatalogLister struct { @@ -116,34 +116,27 @@ func (c *clusterCatalogController) Lister() ClusterCatalogLister { } } -func (c *clusterCatalogController) AddHandler(name string, handler ClusterCatalogHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterCatalogController) AddHandler(ctx context.Context, name string, handler ClusterCatalogHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterCatalog); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ClusterCatalog)) }) } -func (c *clusterCatalogController) AddClusterScopedHandler(name, cluster string, handler ClusterCatalogHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterCatalogController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterCatalogHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterCatalog); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ClusterCatalog)) }) } @@ -238,20 +231,20 @@ func (s *clusterCatalogClient) DeleteCollection(deleteOpts *metav1.DeleteOptions return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterCatalogClient) AddHandler(name string, sync ClusterCatalogHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterCatalogClient) AddHandler(ctx context.Context, name string, sync ClusterCatalogHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterCatalogClient) AddLifecycle(name string, lifecycle ClusterCatalogLifecycle) { +func (s *clusterCatalogClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterCatalogLifecycle) { sync := NewClusterCatalogLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterCatalogClient) AddClusterScopedHandler(name, clusterName string, sync ClusterCatalogHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterCatalogClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterCatalogHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterCatalogClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterCatalogLifecycle) { +func (s *clusterCatalogClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterCatalogLifecycle) { sync := NewClusterCatalogLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_catalog_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_catalog_lifecycle_adapter.go index 78918ae1..3c25ac69 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_catalog_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_catalog_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *clusterCatalogLifecycleAdapter) Updated(obj runtime.Object) (runtime.Ob func NewClusterCatalogLifecycleAdapter(name string, clusterScoped bool, client ClusterCatalogInterface, l ClusterCatalogLifecycle) ClusterCatalogHandlerFunc { adapter := &clusterCatalogLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ClusterCatalog) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ClusterCatalog) (*ClusterCatalog, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ClusterCatalog); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 6f178015..e01a67a9 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_controller.go @@ -34,7 +34,7 @@ type ClusterList struct { Items []Cluster } -type ClusterHandlerFunc func(key string, obj *Cluster) error +type ClusterHandlerFunc func(key string, obj *Cluster) (*Cluster, error) type ClusterLister interface { List(namespace string, selector labels.Selector) (ret []*Cluster, err error) @@ -45,8 +45,8 @@ type ClusterController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterLister - AddHandler(name string, handler ClusterHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type ClusterInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterController - AddHandler(name string, sync ClusterHandlerFunc) - AddLifecycle(name string, lifecycle ClusterLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterLifecycle) } type clusterLister struct { @@ -115,34 +115,27 @@ func (c *clusterController) Lister() ClusterLister { } } -func (c *clusterController) AddHandler(name string, handler ClusterHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterController) AddHandler(ctx context.Context, name string, handler ClusterHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Cluster); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Cluster)) }) } -func (c *clusterController) AddClusterScopedHandler(name, cluster string, handler ClusterHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Cluster); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Cluster)) }) } @@ -237,20 +230,20 @@ func (s *clusterClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterClient) AddHandler(name string, sync ClusterHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterClient) AddHandler(ctx context.Context, name string, sync ClusterHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterClient) AddLifecycle(name string, lifecycle ClusterLifecycle) { +func (s *clusterClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterLifecycle) { sync := NewClusterLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterClient) AddClusterScopedHandler(name, clusterName string, sync ClusterHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterLifecycle) { +func (s *clusterClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterLifecycle) { sync := NewClusterLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_lifecycle_adapter.go index edcec692..2406e8e2 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *clusterLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewClusterLifecycleAdapter(name string, clusterScoped bool, client ClusterInterface, l ClusterLifecycle) ClusterHandlerFunc { adapter := &clusterLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Cluster) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Cluster) (*Cluster, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Cluster); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 908406f1..95fac18d 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 @@ -35,7 +35,7 @@ type ClusterLoggingList struct { Items []ClusterLogging } -type ClusterLoggingHandlerFunc func(key string, obj *ClusterLogging) error +type ClusterLoggingHandlerFunc func(key string, obj *ClusterLogging) (*ClusterLogging, error) type ClusterLoggingLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterLogging, err error) @@ -46,8 +46,8 @@ type ClusterLoggingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterLoggingLister - AddHandler(name string, handler ClusterLoggingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterLoggingHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterLoggingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterLoggingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterLoggingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterLoggingController - AddHandler(name string, sync ClusterLoggingHandlerFunc) - AddLifecycle(name string, lifecycle ClusterLoggingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterLoggingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterLoggingLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterLoggingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterLoggingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterLoggingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterLoggingLifecycle) } type clusterLoggingLister struct { @@ -116,34 +116,27 @@ func (c *clusterLoggingController) Lister() ClusterLoggingLister { } } -func (c *clusterLoggingController) AddHandler(name string, handler ClusterLoggingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterLoggingController) AddHandler(ctx context.Context, name string, handler ClusterLoggingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterLogging); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ClusterLogging)) }) } -func (c *clusterLoggingController) AddClusterScopedHandler(name, cluster string, handler ClusterLoggingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterLoggingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterLoggingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterLogging); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ClusterLogging)) }) } @@ -238,20 +231,20 @@ func (s *clusterLoggingClient) DeleteCollection(deleteOpts *metav1.DeleteOptions return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterLoggingClient) AddHandler(name string, sync ClusterLoggingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterLoggingClient) AddHandler(ctx context.Context, name string, sync ClusterLoggingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterLoggingClient) AddLifecycle(name string, lifecycle ClusterLoggingLifecycle) { +func (s *clusterLoggingClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterLoggingLifecycle) { sync := NewClusterLoggingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterLoggingClient) AddClusterScopedHandler(name, clusterName string, sync ClusterLoggingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterLoggingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterLoggingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterLoggingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterLoggingLifecycle) { +func (s *clusterLoggingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterLoggingLifecycle) { sync := NewClusterLoggingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_logging_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_logging_lifecycle_adapter.go index 7934ff70..2d9cdf29 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_logging_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_logging_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *clusterLoggingLifecycleAdapter) Updated(obj runtime.Object) (runtime.Ob func NewClusterLoggingLifecycleAdapter(name string, clusterScoped bool, client ClusterLoggingInterface, l ClusterLoggingLifecycle) ClusterLoggingHandlerFunc { adapter := &clusterLoggingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ClusterLogging) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ClusterLogging) (*ClusterLogging, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ClusterLogging); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 b13fa594..13fa7deb 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 @@ -35,7 +35,7 @@ type ClusterRegistrationTokenList struct { Items []ClusterRegistrationToken } -type ClusterRegistrationTokenHandlerFunc func(key string, obj *ClusterRegistrationToken) error +type ClusterRegistrationTokenHandlerFunc func(key string, obj *ClusterRegistrationToken) (*ClusterRegistrationToken, error) type ClusterRegistrationTokenLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterRegistrationToken, err error) @@ -46,8 +46,8 @@ type ClusterRegistrationTokenController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterRegistrationTokenLister - AddHandler(name string, handler ClusterRegistrationTokenHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterRegistrationTokenHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterRegistrationTokenHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterRegistrationTokenHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterRegistrationTokenInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterRegistrationTokenController - AddHandler(name string, sync ClusterRegistrationTokenHandlerFunc) - AddLifecycle(name string, lifecycle ClusterRegistrationTokenLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterRegistrationTokenHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRegistrationTokenLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterRegistrationTokenHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterRegistrationTokenLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRegistrationTokenHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRegistrationTokenLifecycle) } type clusterRegistrationTokenLister struct { @@ -116,34 +116,27 @@ func (c *clusterRegistrationTokenController) Lister() ClusterRegistrationTokenLi } } -func (c *clusterRegistrationTokenController) AddHandler(name string, handler ClusterRegistrationTokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRegistrationTokenController) AddHandler(ctx context.Context, name string, handler ClusterRegistrationTokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterRegistrationToken); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ClusterRegistrationToken)) }) } -func (c *clusterRegistrationTokenController) AddClusterScopedHandler(name, cluster string, handler ClusterRegistrationTokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRegistrationTokenController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterRegistrationTokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterRegistrationToken); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ClusterRegistrationToken)) }) } @@ -238,20 +231,20 @@ func (s *clusterRegistrationTokenClient) DeleteCollection(deleteOpts *metav1.Del return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterRegistrationTokenClient) AddHandler(name string, sync ClusterRegistrationTokenHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterRegistrationTokenClient) AddHandler(ctx context.Context, name string, sync ClusterRegistrationTokenHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRegistrationTokenClient) AddLifecycle(name string, lifecycle ClusterRegistrationTokenLifecycle) { +func (s *clusterRegistrationTokenClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterRegistrationTokenLifecycle) { sync := NewClusterRegistrationTokenLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRegistrationTokenClient) AddClusterScopedHandler(name, clusterName string, sync ClusterRegistrationTokenHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterRegistrationTokenClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRegistrationTokenHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterRegistrationTokenClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRegistrationTokenLifecycle) { +func (s *clusterRegistrationTokenClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRegistrationTokenLifecycle) { sync := NewClusterRegistrationTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_lifecycle_adapter.go index 3a7b19c9..93cd4de3 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_registration_token_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *clusterRegistrationTokenLifecycleAdapter) Updated(obj runtime.Object) ( func NewClusterRegistrationTokenLifecycleAdapter(name string, clusterScoped bool, client ClusterRegistrationTokenInterface, l ClusterRegistrationTokenLifecycle) ClusterRegistrationTokenHandlerFunc { adapter := &clusterRegistrationTokenLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ClusterRegistrationToken) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ClusterRegistrationToken) (*ClusterRegistrationToken, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ClusterRegistrationToken); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 d788b849..b4087c79 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 @@ -35,7 +35,7 @@ type ClusterRoleTemplateBindingList struct { Items []ClusterRoleTemplateBinding } -type ClusterRoleTemplateBindingHandlerFunc func(key string, obj *ClusterRoleTemplateBinding) error +type ClusterRoleTemplateBindingHandlerFunc func(key string, obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error) type ClusterRoleTemplateBindingLister interface { List(namespace string, selector labels.Selector) (ret []*ClusterRoleTemplateBinding, err error) @@ -46,8 +46,8 @@ type ClusterRoleTemplateBindingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterRoleTemplateBindingLister - AddHandler(name string, handler ClusterRoleTemplateBindingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterRoleTemplateBindingHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterRoleTemplateBindingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterRoleTemplateBindingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterRoleTemplateBindingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterRoleTemplateBindingController - AddHandler(name string, sync ClusterRoleTemplateBindingHandlerFunc) - AddLifecycle(name string, lifecycle ClusterRoleTemplateBindingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterRoleTemplateBindingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRoleTemplateBindingLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterRoleTemplateBindingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleTemplateBindingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleTemplateBindingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleTemplateBindingLifecycle) } type clusterRoleTemplateBindingLister struct { @@ -116,34 +116,27 @@ func (c *clusterRoleTemplateBindingController) Lister() ClusterRoleTemplateBindi } } -func (c *clusterRoleTemplateBindingController) AddHandler(name string, handler ClusterRoleTemplateBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRoleTemplateBindingController) AddHandler(ctx context.Context, name string, handler ClusterRoleTemplateBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterRoleTemplateBinding); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ClusterRoleTemplateBinding)) }) } -func (c *clusterRoleTemplateBindingController) AddClusterScopedHandler(name, cluster string, handler ClusterRoleTemplateBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRoleTemplateBindingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterRoleTemplateBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ClusterRoleTemplateBinding); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ClusterRoleTemplateBinding)) }) } @@ -238,20 +231,20 @@ func (s *clusterRoleTemplateBindingClient) DeleteCollection(deleteOpts *metav1.D return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterRoleTemplateBindingClient) AddHandler(name string, sync ClusterRoleTemplateBindingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterRoleTemplateBindingClient) AddHandler(ctx context.Context, name string, sync ClusterRoleTemplateBindingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRoleTemplateBindingClient) AddLifecycle(name string, lifecycle ClusterRoleTemplateBindingLifecycle) { +func (s *clusterRoleTemplateBindingClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleTemplateBindingLifecycle) { sync := NewClusterRoleTemplateBindingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRoleTemplateBindingClient) AddClusterScopedHandler(name, clusterName string, sync ClusterRoleTemplateBindingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterRoleTemplateBindingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleTemplateBindingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterRoleTemplateBindingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRoleTemplateBindingLifecycle) { +func (s *clusterRoleTemplateBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleTemplateBindingLifecycle) { sync := NewClusterRoleTemplateBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_lifecycle_adapter.go index c745da7c..66e351e0 100644 --- a/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_cluster_role_template_binding_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *clusterRoleTemplateBindingLifecycleAdapter) Updated(obj runtime.Object) func NewClusterRoleTemplateBindingLifecycleAdapter(name string, clusterScoped bool, client ClusterRoleTemplateBindingInterface, l ClusterRoleTemplateBindingLifecycle) ClusterRoleTemplateBindingHandlerFunc { adapter := &clusterRoleTemplateBindingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ClusterRoleTemplateBinding) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ClusterRoleTemplateBinding) (*ClusterRoleTemplateBinding, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ClusterRoleTemplateBinding); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 33b66191..f301386e 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 @@ -34,7 +34,7 @@ type ComposeConfigList struct { Items []ComposeConfig } -type ComposeConfigHandlerFunc func(key string, obj *ComposeConfig) error +type ComposeConfigHandlerFunc func(key string, obj *ComposeConfig) (*ComposeConfig, error) type ComposeConfigLister interface { List(namespace string, selector labels.Selector) (ret []*ComposeConfig, err error) @@ -45,8 +45,8 @@ type ComposeConfigController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ComposeConfigLister - AddHandler(name string, handler ComposeConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ComposeConfigHandlerFunc) + AddHandler(ctx context.Context, name string, handler ComposeConfigHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ComposeConfigHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type ComposeConfigInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ComposeConfigController - AddHandler(name string, sync ComposeConfigHandlerFunc) - AddLifecycle(name string, lifecycle ComposeConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ComposeConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ComposeConfigLifecycle) + AddHandler(ctx context.Context, name string, sync ComposeConfigHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ComposeConfigLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ComposeConfigHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ComposeConfigLifecycle) } type composeConfigLister struct { @@ -115,34 +115,27 @@ func (c *composeConfigController) Lister() ComposeConfigLister { } } -func (c *composeConfigController) AddHandler(name string, handler ComposeConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *composeConfigController) AddHandler(ctx context.Context, name string, handler ComposeConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ComposeConfig); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ComposeConfig)) }) } -func (c *composeConfigController) AddClusterScopedHandler(name, cluster string, handler ComposeConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *composeConfigController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ComposeConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ComposeConfig); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ComposeConfig)) }) } @@ -237,20 +230,20 @@ func (s *composeConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *composeConfigClient) AddHandler(name string, sync ComposeConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *composeConfigClient) AddHandler(ctx context.Context, name string, sync ComposeConfigHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *composeConfigClient) AddLifecycle(name string, lifecycle ComposeConfigLifecycle) { +func (s *composeConfigClient) AddLifecycle(ctx context.Context, name string, lifecycle ComposeConfigLifecycle) { sync := NewComposeConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *composeConfigClient) AddClusterScopedHandler(name, clusterName string, sync ComposeConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *composeConfigClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ComposeConfigHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *composeConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ComposeConfigLifecycle) { +func (s *composeConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ComposeConfigLifecycle) { sync := NewComposeConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go index 96a5ea75..8588db33 100644 --- a/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *composeConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obj func NewComposeConfigLifecycleAdapter(name string, clusterScoped bool, client ComposeConfigInterface, l ComposeConfigLifecycle) ComposeConfigHandlerFunc { adapter := &composeConfigLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ComposeConfig) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ComposeConfig) (*ComposeConfig, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ComposeConfig); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 9793bb90..2332b877 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 @@ -34,7 +34,7 @@ type DynamicSchemaList struct { Items []DynamicSchema } -type DynamicSchemaHandlerFunc func(key string, obj *DynamicSchema) error +type DynamicSchemaHandlerFunc func(key string, obj *DynamicSchema) (*DynamicSchema, error) type DynamicSchemaLister interface { List(namespace string, selector labels.Selector) (ret []*DynamicSchema, err error) @@ -45,8 +45,8 @@ type DynamicSchemaController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() DynamicSchemaLister - AddHandler(name string, handler DynamicSchemaHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler DynamicSchemaHandlerFunc) + AddHandler(ctx context.Context, name string, handler DynamicSchemaHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler DynamicSchemaHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type DynamicSchemaInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() DynamicSchemaController - AddHandler(name string, sync DynamicSchemaHandlerFunc) - AddLifecycle(name string, lifecycle DynamicSchemaLifecycle) - AddClusterScopedHandler(name, clusterName string, sync DynamicSchemaHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle DynamicSchemaLifecycle) + AddHandler(ctx context.Context, name string, sync DynamicSchemaHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle DynamicSchemaLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DynamicSchemaHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DynamicSchemaLifecycle) } type dynamicSchemaLister struct { @@ -115,34 +115,27 @@ func (c *dynamicSchemaController) Lister() DynamicSchemaLister { } } -func (c *dynamicSchemaController) AddHandler(name string, handler DynamicSchemaHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *dynamicSchemaController) AddHandler(ctx context.Context, name string, handler DynamicSchemaHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*DynamicSchema); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*DynamicSchema)) }) } -func (c *dynamicSchemaController) AddClusterScopedHandler(name, cluster string, handler DynamicSchemaHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *dynamicSchemaController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler DynamicSchemaHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*DynamicSchema); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*DynamicSchema)) }) } @@ -237,20 +230,20 @@ func (s *dynamicSchemaClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *dynamicSchemaClient) AddHandler(name string, sync DynamicSchemaHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *dynamicSchemaClient) AddHandler(ctx context.Context, name string, sync DynamicSchemaHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *dynamicSchemaClient) AddLifecycle(name string, lifecycle DynamicSchemaLifecycle) { +func (s *dynamicSchemaClient) AddLifecycle(ctx context.Context, name string, lifecycle DynamicSchemaLifecycle) { sync := NewDynamicSchemaLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *dynamicSchemaClient) AddClusterScopedHandler(name, clusterName string, sync DynamicSchemaHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *dynamicSchemaClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DynamicSchemaHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *dynamicSchemaClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle DynamicSchemaLifecycle) { +func (s *dynamicSchemaClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DynamicSchemaLifecycle) { sync := NewDynamicSchemaLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_dynamic_schema_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_dynamic_schema_lifecycle_adapter.go index c97f05c3..6382f9ee 100644 --- a/apis/management.cattle.io/v3/zz_generated_dynamic_schema_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_dynamic_schema_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *dynamicSchemaLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obj func NewDynamicSchemaLifecycleAdapter(name string, clusterScoped bool, client DynamicSchemaInterface, l DynamicSchemaLifecycle) DynamicSchemaHandlerFunc { adapter := &dynamicSchemaLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *DynamicSchema) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *DynamicSchema) (*DynamicSchema, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*DynamicSchema); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 da85d1ad..edfed0b4 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 @@ -34,7 +34,7 @@ type GlobalRoleBindingList struct { Items []GlobalRoleBinding } -type GlobalRoleBindingHandlerFunc func(key string, obj *GlobalRoleBinding) error +type GlobalRoleBindingHandlerFunc func(key string, obj *GlobalRoleBinding) (*GlobalRoleBinding, error) type GlobalRoleBindingLister interface { List(namespace string, selector labels.Selector) (ret []*GlobalRoleBinding, err error) @@ -45,8 +45,8 @@ type GlobalRoleBindingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() GlobalRoleBindingLister - AddHandler(name string, handler GlobalRoleBindingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler GlobalRoleBindingHandlerFunc) + AddHandler(ctx context.Context, name string, handler GlobalRoleBindingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GlobalRoleBindingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type GlobalRoleBindingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() GlobalRoleBindingController - AddHandler(name string, sync GlobalRoleBindingHandlerFunc) - AddLifecycle(name string, lifecycle GlobalRoleBindingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync GlobalRoleBindingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle GlobalRoleBindingLifecycle) + AddHandler(ctx context.Context, name string, sync GlobalRoleBindingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle GlobalRoleBindingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalRoleBindingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalRoleBindingLifecycle) } type globalRoleBindingLister struct { @@ -115,34 +115,27 @@ func (c *globalRoleBindingController) Lister() GlobalRoleBindingLister { } } -func (c *globalRoleBindingController) AddHandler(name string, handler GlobalRoleBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *globalRoleBindingController) AddHandler(ctx context.Context, name string, handler GlobalRoleBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*GlobalRoleBinding); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*GlobalRoleBinding)) }) } -func (c *globalRoleBindingController) AddClusterScopedHandler(name, cluster string, handler GlobalRoleBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *globalRoleBindingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler GlobalRoleBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*GlobalRoleBinding); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*GlobalRoleBinding)) }) } @@ -237,20 +230,20 @@ func (s *globalRoleBindingClient) DeleteCollection(deleteOpts *metav1.DeleteOpti return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *globalRoleBindingClient) AddHandler(name string, sync GlobalRoleBindingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *globalRoleBindingClient) AddHandler(ctx context.Context, name string, sync GlobalRoleBindingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *globalRoleBindingClient) AddLifecycle(name string, lifecycle GlobalRoleBindingLifecycle) { +func (s *globalRoleBindingClient) AddLifecycle(ctx context.Context, name string, lifecycle GlobalRoleBindingLifecycle) { sync := NewGlobalRoleBindingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *globalRoleBindingClient) AddClusterScopedHandler(name, clusterName string, sync GlobalRoleBindingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *globalRoleBindingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalRoleBindingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *globalRoleBindingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle GlobalRoleBindingLifecycle) { +func (s *globalRoleBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalRoleBindingLifecycle) { sync := NewGlobalRoleBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_global_role_binding_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_global_role_binding_lifecycle_adapter.go index 1aa7803d..db0b11eb 100644 --- a/apis/management.cattle.io/v3/zz_generated_global_role_binding_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_global_role_binding_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *globalRoleBindingLifecycleAdapter) Updated(obj runtime.Object) (runtime func NewGlobalRoleBindingLifecycleAdapter(name string, clusterScoped bool, client GlobalRoleBindingInterface, l GlobalRoleBindingLifecycle) GlobalRoleBindingHandlerFunc { adapter := &globalRoleBindingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *GlobalRoleBinding) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *GlobalRoleBinding) (*GlobalRoleBinding, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*GlobalRoleBinding); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 fe982dde..0f474768 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 @@ -34,7 +34,7 @@ type GlobalRoleList struct { Items []GlobalRole } -type GlobalRoleHandlerFunc func(key string, obj *GlobalRole) error +type GlobalRoleHandlerFunc func(key string, obj *GlobalRole) (*GlobalRole, error) type GlobalRoleLister interface { List(namespace string, selector labels.Selector) (ret []*GlobalRole, err error) @@ -45,8 +45,8 @@ type GlobalRoleController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() GlobalRoleLister - AddHandler(name string, handler GlobalRoleHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler GlobalRoleHandlerFunc) + AddHandler(ctx context.Context, name string, handler GlobalRoleHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GlobalRoleHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type GlobalRoleInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() GlobalRoleController - AddHandler(name string, sync GlobalRoleHandlerFunc) - AddLifecycle(name string, lifecycle GlobalRoleLifecycle) - AddClusterScopedHandler(name, clusterName string, sync GlobalRoleHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle GlobalRoleLifecycle) + AddHandler(ctx context.Context, name string, sync GlobalRoleHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle GlobalRoleLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalRoleHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalRoleLifecycle) } type globalRoleLister struct { @@ -115,34 +115,27 @@ func (c *globalRoleController) Lister() GlobalRoleLister { } } -func (c *globalRoleController) AddHandler(name string, handler GlobalRoleHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *globalRoleController) AddHandler(ctx context.Context, name string, handler GlobalRoleHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*GlobalRole); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*GlobalRole)) }) } -func (c *globalRoleController) AddClusterScopedHandler(name, cluster string, handler GlobalRoleHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *globalRoleController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler GlobalRoleHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*GlobalRole); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*GlobalRole)) }) } @@ -237,20 +230,20 @@ func (s *globalRoleClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *globalRoleClient) AddHandler(name string, sync GlobalRoleHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *globalRoleClient) AddHandler(ctx context.Context, name string, sync GlobalRoleHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *globalRoleClient) AddLifecycle(name string, lifecycle GlobalRoleLifecycle) { +func (s *globalRoleClient) AddLifecycle(ctx context.Context, name string, lifecycle GlobalRoleLifecycle) { sync := NewGlobalRoleLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *globalRoleClient) AddClusterScopedHandler(name, clusterName string, sync GlobalRoleHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *globalRoleClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GlobalRoleHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *globalRoleClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle GlobalRoleLifecycle) { +func (s *globalRoleClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GlobalRoleLifecycle) { sync := NewGlobalRoleLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_global_role_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_global_role_lifecycle_adapter.go index b44ff74a..6e29b18a 100644 --- a/apis/management.cattle.io/v3/zz_generated_global_role_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_global_role_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *globalRoleLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewGlobalRoleLifecycleAdapter(name string, clusterScoped bool, client GlobalRoleInterface, l GlobalRoleLifecycle) GlobalRoleHandlerFunc { adapter := &globalRoleLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *GlobalRole) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *GlobalRole) (*GlobalRole, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*GlobalRole); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 8f99c262..7c59e4fa 100644 --- a/apis/management.cattle.io/v3/zz_generated_group_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_group_controller.go @@ -34,7 +34,7 @@ type GroupList struct { Items []Group } -type GroupHandlerFunc func(key string, obj *Group) error +type GroupHandlerFunc func(key string, obj *Group) (*Group, error) type GroupLister interface { List(namespace string, selector labels.Selector) (ret []*Group, err error) @@ -45,8 +45,8 @@ type GroupController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() GroupLister - AddHandler(name string, handler GroupHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler GroupHandlerFunc) + AddHandler(ctx context.Context, name string, handler GroupHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GroupHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type GroupInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() GroupController - AddHandler(name string, sync GroupHandlerFunc) - AddLifecycle(name string, lifecycle GroupLifecycle) - AddClusterScopedHandler(name, clusterName string, sync GroupHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle GroupLifecycle) + AddHandler(ctx context.Context, name string, sync GroupHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle GroupLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GroupHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GroupLifecycle) } type groupLister struct { @@ -115,34 +115,27 @@ func (c *groupController) Lister() GroupLister { } } -func (c *groupController) AddHandler(name string, handler GroupHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *groupController) AddHandler(ctx context.Context, name string, handler GroupHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Group); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Group)) }) } -func (c *groupController) AddClusterScopedHandler(name, cluster string, handler GroupHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *groupController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler GroupHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Group); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Group)) }) } @@ -237,20 +230,20 @@ func (s *groupClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpt return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *groupClient) AddHandler(name string, sync GroupHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *groupClient) AddHandler(ctx context.Context, name string, sync GroupHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *groupClient) AddLifecycle(name string, lifecycle GroupLifecycle) { +func (s *groupClient) AddLifecycle(ctx context.Context, name string, lifecycle GroupLifecycle) { sync := NewGroupLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *groupClient) AddClusterScopedHandler(name, clusterName string, sync GroupHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *groupClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GroupHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *groupClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle GroupLifecycle) { +func (s *groupClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GroupLifecycle) { sync := NewGroupLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_group_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_group_lifecycle_adapter.go index bc1b2fcd..cd929d0f 100644 --- a/apis/management.cattle.io/v3/zz_generated_group_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_group_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *groupLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, err func NewGroupLifecycleAdapter(name string, clusterScoped bool, client GroupInterface, l GroupLifecycle) GroupHandlerFunc { adapter := &groupLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Group) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Group) (*Group, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Group); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 b20b4425..4d80bcac 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 @@ -34,7 +34,7 @@ type GroupMemberList struct { Items []GroupMember } -type GroupMemberHandlerFunc func(key string, obj *GroupMember) error +type GroupMemberHandlerFunc func(key string, obj *GroupMember) (*GroupMember, error) type GroupMemberLister interface { List(namespace string, selector labels.Selector) (ret []*GroupMember, err error) @@ -45,8 +45,8 @@ type GroupMemberController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() GroupMemberLister - AddHandler(name string, handler GroupMemberHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler GroupMemberHandlerFunc) + AddHandler(ctx context.Context, name string, handler GroupMemberHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler GroupMemberHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type GroupMemberInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() GroupMemberController - AddHandler(name string, sync GroupMemberHandlerFunc) - AddLifecycle(name string, lifecycle GroupMemberLifecycle) - AddClusterScopedHandler(name, clusterName string, sync GroupMemberHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle GroupMemberLifecycle) + AddHandler(ctx context.Context, name string, sync GroupMemberHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle GroupMemberLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GroupMemberHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GroupMemberLifecycle) } type groupMemberLister struct { @@ -115,34 +115,27 @@ func (c *groupMemberController) Lister() GroupMemberLister { } } -func (c *groupMemberController) AddHandler(name string, handler GroupMemberHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *groupMemberController) AddHandler(ctx context.Context, name string, handler GroupMemberHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*GroupMember); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*GroupMember)) }) } -func (c *groupMemberController) AddClusterScopedHandler(name, cluster string, handler GroupMemberHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *groupMemberController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler GroupMemberHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*GroupMember); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*GroupMember)) }) } @@ -237,20 +230,20 @@ func (s *groupMemberClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, l return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *groupMemberClient) AddHandler(name string, sync GroupMemberHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *groupMemberClient) AddHandler(ctx context.Context, name string, sync GroupMemberHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *groupMemberClient) AddLifecycle(name string, lifecycle GroupMemberLifecycle) { +func (s *groupMemberClient) AddLifecycle(ctx context.Context, name string, lifecycle GroupMemberLifecycle) { sync := NewGroupMemberLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *groupMemberClient) AddClusterScopedHandler(name, clusterName string, sync GroupMemberHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *groupMemberClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync GroupMemberHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *groupMemberClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle GroupMemberLifecycle) { +func (s *groupMemberClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle GroupMemberLifecycle) { sync := NewGroupMemberLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_group_member_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_group_member_lifecycle_adapter.go index e86df9fe..dc31cf66 100644 --- a/apis/management.cattle.io/v3/zz_generated_group_member_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_group_member_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *groupMemberLifecycleAdapter) Updated(obj runtime.Object) (runtime.Objec func NewGroupMemberLifecycleAdapter(name string, clusterScoped bool, client GroupMemberInterface, l GroupMemberLifecycle) GroupMemberHandlerFunc { adapter := &groupMemberLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *GroupMember) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *GroupMember) (*GroupMember, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*GroupMember); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 66e52a93..73993582 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 @@ -34,7 +34,7 @@ type LdapConfigList struct { Items []LdapConfig } -type LdapConfigHandlerFunc func(key string, obj *LdapConfig) error +type LdapConfigHandlerFunc func(key string, obj *LdapConfig) (*LdapConfig, error) type LdapConfigLister interface { List(namespace string, selector labels.Selector) (ret []*LdapConfig, err error) @@ -45,8 +45,8 @@ type LdapConfigController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() LdapConfigLister - AddHandler(name string, handler LdapConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler LdapConfigHandlerFunc) + AddHandler(ctx context.Context, name string, handler LdapConfigHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler LdapConfigHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type LdapConfigInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() LdapConfigController - AddHandler(name string, sync LdapConfigHandlerFunc) - AddLifecycle(name string, lifecycle LdapConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync LdapConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle LdapConfigLifecycle) + AddHandler(ctx context.Context, name string, sync LdapConfigHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle LdapConfigLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync LdapConfigHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle LdapConfigLifecycle) } type ldapConfigLister struct { @@ -115,34 +115,27 @@ func (c *ldapConfigController) Lister() LdapConfigLister { } } -func (c *ldapConfigController) AddHandler(name string, handler LdapConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *ldapConfigController) AddHandler(ctx context.Context, name string, handler LdapConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*LdapConfig); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*LdapConfig)) }) } -func (c *ldapConfigController) AddClusterScopedHandler(name, cluster string, handler LdapConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *ldapConfigController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler LdapConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*LdapConfig); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*LdapConfig)) }) } @@ -237,20 +230,20 @@ func (s *ldapConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *ldapConfigClient) AddHandler(name string, sync LdapConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *ldapConfigClient) AddHandler(ctx context.Context, name string, sync LdapConfigHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *ldapConfigClient) AddLifecycle(name string, lifecycle LdapConfigLifecycle) { +func (s *ldapConfigClient) AddLifecycle(ctx context.Context, name string, lifecycle LdapConfigLifecycle) { sync := NewLdapConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *ldapConfigClient) AddClusterScopedHandler(name, clusterName string, sync LdapConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *ldapConfigClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync LdapConfigHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *ldapConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle LdapConfigLifecycle) { +func (s *ldapConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle LdapConfigLifecycle) { sync := NewLdapConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_ldap_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_ldap_config_lifecycle_adapter.go index beb2c4a5..380e67c8 100644 --- a/apis/management.cattle.io/v3/zz_generated_ldap_config_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_ldap_config_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *ldapConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewLdapConfigLifecycleAdapter(name string, clusterScoped bool, client LdapConfigInterface, l LdapConfigLifecycle) LdapConfigHandlerFunc { adapter := &ldapConfigLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *LdapConfig) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *LdapConfig) (*LdapConfig, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*LdapConfig); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 5d9061a1..82ff5030 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 @@ -34,7 +34,7 @@ type ListenConfigList struct { Items []ListenConfig } -type ListenConfigHandlerFunc func(key string, obj *ListenConfig) error +type ListenConfigHandlerFunc func(key string, obj *ListenConfig) (*ListenConfig, error) type ListenConfigLister interface { List(namespace string, selector labels.Selector) (ret []*ListenConfig, err error) @@ -45,8 +45,8 @@ type ListenConfigController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ListenConfigLister - AddHandler(name string, handler ListenConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ListenConfigHandlerFunc) + AddHandler(ctx context.Context, name string, handler ListenConfigHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ListenConfigHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type ListenConfigInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ListenConfigController - AddHandler(name string, sync ListenConfigHandlerFunc) - AddLifecycle(name string, lifecycle ListenConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ListenConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ListenConfigLifecycle) + AddHandler(ctx context.Context, name string, sync ListenConfigHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ListenConfigLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ListenConfigHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ListenConfigLifecycle) } type listenConfigLister struct { @@ -115,34 +115,27 @@ func (c *listenConfigController) Lister() ListenConfigLister { } } -func (c *listenConfigController) AddHandler(name string, handler ListenConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *listenConfigController) AddHandler(ctx context.Context, name string, handler ListenConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ListenConfig); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ListenConfig)) }) } -func (c *listenConfigController) AddClusterScopedHandler(name, cluster string, handler ListenConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *listenConfigController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ListenConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ListenConfig); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ListenConfig)) }) } @@ -237,20 +230,20 @@ func (s *listenConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *listenConfigClient) AddHandler(name string, sync ListenConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *listenConfigClient) AddHandler(ctx context.Context, name string, sync ListenConfigHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *listenConfigClient) AddLifecycle(name string, lifecycle ListenConfigLifecycle) { +func (s *listenConfigClient) AddLifecycle(ctx context.Context, name string, lifecycle ListenConfigLifecycle) { sync := NewListenConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *listenConfigClient) AddClusterScopedHandler(name, clusterName string, sync ListenConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *listenConfigClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ListenConfigHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *listenConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ListenConfigLifecycle) { +func (s *listenConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ListenConfigLifecycle) { sync := NewListenConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_listen_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_listen_config_lifecycle_adapter.go index eb7dcff2..d17f7d84 100644 --- a/apis/management.cattle.io/v3/zz_generated_listen_config_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_listen_config_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *listenConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obje func NewListenConfigLifecycleAdapter(name string, clusterScoped bool, client ListenConfigInterface, l ListenConfigLifecycle) ListenConfigHandlerFunc { adapter := &listenConfigLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ListenConfig) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ListenConfig) (*ListenConfig, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ListenConfig); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 c9691faf..8bdb2501 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_node_controller.go @@ -35,7 +35,7 @@ type NodeList struct { Items []Node } -type NodeHandlerFunc func(key string, obj *Node) error +type NodeHandlerFunc func(key string, obj *Node) (*Node, error) type NodeLister interface { List(namespace string, selector labels.Selector) (ret []*Node, err error) @@ -46,8 +46,8 @@ type NodeController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NodeLister - AddHandler(name string, handler NodeHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NodeHandlerFunc) + AddHandler(ctx context.Context, name string, handler NodeHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NodeInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NodeController - AddHandler(name string, sync NodeHandlerFunc) - AddLifecycle(name string, lifecycle NodeLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NodeHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeLifecycle) + AddHandler(ctx context.Context, name string, sync NodeHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NodeLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeLifecycle) } type nodeLister struct { @@ -116,34 +116,27 @@ func (c *nodeController) Lister() NodeLister { } } -func (c *nodeController) AddHandler(name string, handler NodeHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeController) AddHandler(ctx context.Context, name string, handler NodeHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Node); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Node)) }) } -func (c *nodeController) AddClusterScopedHandler(name, cluster string, handler NodeHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NodeHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Node); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Node)) }) } @@ -238,20 +231,20 @@ func (s *nodeClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *nodeClient) AddHandler(name string, sync NodeHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *nodeClient) AddHandler(ctx context.Context, name string, sync NodeHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeClient) AddLifecycle(name string, lifecycle NodeLifecycle) { +func (s *nodeClient) AddLifecycle(ctx context.Context, name string, lifecycle NodeLifecycle) { sync := NewNodeLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeClient) AddClusterScopedHandler(name, clusterName string, sync NodeHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *nodeClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *nodeClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeLifecycle) { +func (s *nodeClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeLifecycle) { sync := NewNodeLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } 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 7a7e1fd0..d197602f 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 @@ -34,7 +34,7 @@ type NodeDriverList struct { Items []NodeDriver } -type NodeDriverHandlerFunc func(key string, obj *NodeDriver) error +type NodeDriverHandlerFunc func(key string, obj *NodeDriver) (*NodeDriver, error) type NodeDriverLister interface { List(namespace string, selector labels.Selector) (ret []*NodeDriver, err error) @@ -45,8 +45,8 @@ type NodeDriverController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NodeDriverLister - AddHandler(name string, handler NodeDriverHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NodeDriverHandlerFunc) + AddHandler(ctx context.Context, name string, handler NodeDriverHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeDriverHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type NodeDriverInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NodeDriverController - AddHandler(name string, sync NodeDriverHandlerFunc) - AddLifecycle(name string, lifecycle NodeDriverLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NodeDriverHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeDriverLifecycle) + AddHandler(ctx context.Context, name string, sync NodeDriverHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NodeDriverLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeDriverHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeDriverLifecycle) } type nodeDriverLister struct { @@ -115,34 +115,27 @@ func (c *nodeDriverController) Lister() NodeDriverLister { } } -func (c *nodeDriverController) AddHandler(name string, handler NodeDriverHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeDriverController) AddHandler(ctx context.Context, name string, handler NodeDriverHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NodeDriver); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NodeDriver)) }) } -func (c *nodeDriverController) AddClusterScopedHandler(name, cluster string, handler NodeDriverHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeDriverController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NodeDriverHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NodeDriver); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NodeDriver)) }) } @@ -237,20 +230,20 @@ func (s *nodeDriverClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *nodeDriverClient) AddHandler(name string, sync NodeDriverHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *nodeDriverClient) AddHandler(ctx context.Context, name string, sync NodeDriverHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeDriverClient) AddLifecycle(name string, lifecycle NodeDriverLifecycle) { +func (s *nodeDriverClient) AddLifecycle(ctx context.Context, name string, lifecycle NodeDriverLifecycle) { sync := NewNodeDriverLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeDriverClient) AddClusterScopedHandler(name, clusterName string, sync NodeDriverHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *nodeDriverClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeDriverHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *nodeDriverClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeDriverLifecycle) { +func (s *nodeDriverClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeDriverLifecycle) { sync := NewNodeDriverLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_node_driver_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_node_driver_lifecycle_adapter.go index 46f3e429..460f89d0 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_driver_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_node_driver_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *nodeDriverLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewNodeDriverLifecycleAdapter(name string, clusterScoped bool, client NodeDriverInterface, l NodeDriverLifecycle) NodeDriverHandlerFunc { adapter := &nodeDriverLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NodeDriver) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NodeDriver) (*NodeDriver, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NodeDriver); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/management.cattle.io/v3/zz_generated_node_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_node_lifecycle_adapter.go index d0a906de..4872b5b7 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_node_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *nodeLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, erro func NewNodeLifecycleAdapter(name string, clusterScoped bool, client NodeInterface, l NodeLifecycle) NodeHandlerFunc { adapter := &nodeLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Node) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Node) (*Node, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Node); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 acf05d3a..dcbfad2e 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 @@ -35,7 +35,7 @@ type NodePoolList struct { Items []NodePool } -type NodePoolHandlerFunc func(key string, obj *NodePool) error +type NodePoolHandlerFunc func(key string, obj *NodePool) (*NodePool, error) type NodePoolLister interface { List(namespace string, selector labels.Selector) (ret []*NodePool, err error) @@ -46,8 +46,8 @@ type NodePoolController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NodePoolLister - AddHandler(name string, handler NodePoolHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NodePoolHandlerFunc) + AddHandler(ctx context.Context, name string, handler NodePoolHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodePoolHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NodePoolInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NodePoolController - AddHandler(name string, sync NodePoolHandlerFunc) - AddLifecycle(name string, lifecycle NodePoolLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NodePoolHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NodePoolLifecycle) + AddHandler(ctx context.Context, name string, sync NodePoolHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NodePoolLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodePoolHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodePoolLifecycle) } type nodePoolLister struct { @@ -116,34 +116,27 @@ func (c *nodePoolController) Lister() NodePoolLister { } } -func (c *nodePoolController) AddHandler(name string, handler NodePoolHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodePoolController) AddHandler(ctx context.Context, name string, handler NodePoolHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NodePool); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NodePool)) }) } -func (c *nodePoolController) AddClusterScopedHandler(name, cluster string, handler NodePoolHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodePoolController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NodePoolHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NodePool); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NodePool)) }) } @@ -238,20 +231,20 @@ func (s *nodePoolClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, list return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *nodePoolClient) AddHandler(name string, sync NodePoolHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *nodePoolClient) AddHandler(ctx context.Context, name string, sync NodePoolHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodePoolClient) AddLifecycle(name string, lifecycle NodePoolLifecycle) { +func (s *nodePoolClient) AddLifecycle(ctx context.Context, name string, lifecycle NodePoolLifecycle) { sync := NewNodePoolLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodePoolClient) AddClusterScopedHandler(name, clusterName string, sync NodePoolHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *nodePoolClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodePoolHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *nodePoolClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NodePoolLifecycle) { +func (s *nodePoolClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodePoolLifecycle) { sync := NewNodePoolLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_node_pool_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_node_pool_lifecycle_adapter.go index ce46d30a..4e13a330 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_pool_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_node_pool_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *nodePoolLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewNodePoolLifecycleAdapter(name string, clusterScoped bool, client NodePoolInterface, l NodePoolLifecycle) NodePoolHandlerFunc { adapter := &nodePoolLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NodePool) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NodePool) (*NodePool, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NodePool); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 83476629..c6e3fa4d 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 @@ -35,7 +35,7 @@ type NodeTemplateList struct { Items []NodeTemplate } -type NodeTemplateHandlerFunc func(key string, obj *NodeTemplate) error +type NodeTemplateHandlerFunc func(key string, obj *NodeTemplate) (*NodeTemplate, error) type NodeTemplateLister interface { List(namespace string, selector labels.Selector) (ret []*NodeTemplate, err error) @@ -46,8 +46,8 @@ type NodeTemplateController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NodeTemplateLister - AddHandler(name string, handler NodeTemplateHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NodeTemplateHandlerFunc) + AddHandler(ctx context.Context, name string, handler NodeTemplateHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodeTemplateHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NodeTemplateInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NodeTemplateController - AddHandler(name string, sync NodeTemplateHandlerFunc) - AddLifecycle(name string, lifecycle NodeTemplateLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NodeTemplateHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeTemplateLifecycle) + AddHandler(ctx context.Context, name string, sync NodeTemplateHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NodeTemplateLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeTemplateHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeTemplateLifecycle) } type nodeTemplateLister struct { @@ -116,34 +116,27 @@ func (c *nodeTemplateController) Lister() NodeTemplateLister { } } -func (c *nodeTemplateController) AddHandler(name string, handler NodeTemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeTemplateController) AddHandler(ctx context.Context, name string, handler NodeTemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NodeTemplate); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NodeTemplate)) }) } -func (c *nodeTemplateController) AddClusterScopedHandler(name, cluster string, handler NodeTemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *nodeTemplateController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NodeTemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NodeTemplate); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NodeTemplate)) }) } @@ -238,20 +231,20 @@ func (s *nodeTemplateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *nodeTemplateClient) AddHandler(name string, sync NodeTemplateHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *nodeTemplateClient) AddHandler(ctx context.Context, name string, sync NodeTemplateHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeTemplateClient) AddLifecycle(name string, lifecycle NodeTemplateLifecycle) { +func (s *nodeTemplateClient) AddLifecycle(ctx context.Context, name string, lifecycle NodeTemplateLifecycle) { sync := NewNodeTemplateLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *nodeTemplateClient) AddClusterScopedHandler(name, clusterName string, sync NodeTemplateHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *nodeTemplateClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodeTemplateHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *nodeTemplateClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NodeTemplateLifecycle) { +func (s *nodeTemplateClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodeTemplateLifecycle) { sync := NewNodeTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_node_template_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_node_template_lifecycle_adapter.go index 7be7ca1d..c4f9f9ad 100644 --- a/apis/management.cattle.io/v3/zz_generated_node_template_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_node_template_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *nodeTemplateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obje func NewNodeTemplateLifecycleAdapter(name string, clusterScoped bool, client NodeTemplateInterface, l NodeTemplateLifecycle) NodeTemplateHandlerFunc { adapter := &nodeTemplateLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NodeTemplate) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NodeTemplate) (*NodeTemplate, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NodeTemplate); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 cdda85e7..76c725ad 100644 --- a/apis/management.cattle.io/v3/zz_generated_notifier_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_notifier_controller.go @@ -35,7 +35,7 @@ type NotifierList struct { Items []Notifier } -type NotifierHandlerFunc func(key string, obj *Notifier) error +type NotifierHandlerFunc func(key string, obj *Notifier) (*Notifier, error) type NotifierLister interface { List(namespace string, selector labels.Selector) (ret []*Notifier, err error) @@ -46,8 +46,8 @@ type NotifierController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NotifierLister - AddHandler(name string, handler NotifierHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NotifierHandlerFunc) + AddHandler(ctx context.Context, name string, handler NotifierHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NotifierHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NotifierInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NotifierController - AddHandler(name string, sync NotifierHandlerFunc) - AddLifecycle(name string, lifecycle NotifierLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NotifierHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NotifierLifecycle) + AddHandler(ctx context.Context, name string, sync NotifierHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NotifierLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NotifierHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NotifierLifecycle) } type notifierLister struct { @@ -116,34 +116,27 @@ func (c *notifierController) Lister() NotifierLister { } } -func (c *notifierController) AddHandler(name string, handler NotifierHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *notifierController) AddHandler(ctx context.Context, name string, handler NotifierHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Notifier); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Notifier)) }) } -func (c *notifierController) AddClusterScopedHandler(name, cluster string, handler NotifierHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *notifierController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NotifierHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Notifier); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Notifier)) }) } @@ -238,20 +231,20 @@ func (s *notifierClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, list return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *notifierClient) AddHandler(name string, sync NotifierHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *notifierClient) AddHandler(ctx context.Context, name string, sync NotifierHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *notifierClient) AddLifecycle(name string, lifecycle NotifierLifecycle) { +func (s *notifierClient) AddLifecycle(ctx context.Context, name string, lifecycle NotifierLifecycle) { sync := NewNotifierLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *notifierClient) AddClusterScopedHandler(name, clusterName string, sync NotifierHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *notifierClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NotifierHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *notifierClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NotifierLifecycle) { +func (s *notifierClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NotifierLifecycle) { sync := NewNotifierLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_notifier_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_notifier_lifecycle_adapter.go index cec2f0dd..a4d87d96 100644 --- a/apis/management.cattle.io/v3/zz_generated_notifier_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_notifier_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *notifierLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewNotifierLifecycleAdapter(name string, clusterScoped bool, client NotifierInterface, l NotifierLifecycle) NotifierHandlerFunc { adapter := ¬ifierLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Notifier) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Notifier) (*Notifier, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Notifier); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 25d46f77..b717c44a 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 @@ -34,7 +34,7 @@ type PodSecurityPolicyTemplateList struct { Items []PodSecurityPolicyTemplate } -type PodSecurityPolicyTemplateHandlerFunc func(key string, obj *PodSecurityPolicyTemplate) error +type PodSecurityPolicyTemplateHandlerFunc func(key string, obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error) type PodSecurityPolicyTemplateLister interface { List(namespace string, selector labels.Selector) (ret []*PodSecurityPolicyTemplate, err error) @@ -45,8 +45,8 @@ type PodSecurityPolicyTemplateController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PodSecurityPolicyTemplateLister - AddHandler(name string, handler PodSecurityPolicyTemplateHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PodSecurityPolicyTemplateHandlerFunc) + AddHandler(ctx context.Context, name string, handler PodSecurityPolicyTemplateHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PodSecurityPolicyTemplateHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type PodSecurityPolicyTemplateInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PodSecurityPolicyTemplateController - AddHandler(name string, sync PodSecurityPolicyTemplateHandlerFunc) - AddLifecycle(name string, lifecycle PodSecurityPolicyTemplateLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PodSecurityPolicyTemplateHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PodSecurityPolicyTemplateLifecycle) + AddHandler(ctx context.Context, name string, sync PodSecurityPolicyTemplateHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyTemplateLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyTemplateHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyTemplateLifecycle) } type podSecurityPolicyTemplateLister struct { @@ -115,34 +115,27 @@ func (c *podSecurityPolicyTemplateController) Lister() PodSecurityPolicyTemplate } } -func (c *podSecurityPolicyTemplateController) AddHandler(name string, handler PodSecurityPolicyTemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podSecurityPolicyTemplateController) AddHandler(ctx context.Context, name string, handler PodSecurityPolicyTemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PodSecurityPolicyTemplate); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*PodSecurityPolicyTemplate)) }) } -func (c *podSecurityPolicyTemplateController) AddClusterScopedHandler(name, cluster string, handler PodSecurityPolicyTemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podSecurityPolicyTemplateController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PodSecurityPolicyTemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PodSecurityPolicyTemplate); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*PodSecurityPolicyTemplate)) }) } @@ -237,20 +230,20 @@ func (s *podSecurityPolicyTemplateClient) DeleteCollection(deleteOpts *metav1.De return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *podSecurityPolicyTemplateClient) AddHandler(name string, sync PodSecurityPolicyTemplateHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *podSecurityPolicyTemplateClient) AddHandler(ctx context.Context, name string, sync PodSecurityPolicyTemplateHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *podSecurityPolicyTemplateClient) AddLifecycle(name string, lifecycle PodSecurityPolicyTemplateLifecycle) { +func (s *podSecurityPolicyTemplateClient) AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyTemplateLifecycle) { sync := NewPodSecurityPolicyTemplateLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *podSecurityPolicyTemplateClient) AddClusterScopedHandler(name, clusterName string, sync PodSecurityPolicyTemplateHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *podSecurityPolicyTemplateClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyTemplateHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *podSecurityPolicyTemplateClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PodSecurityPolicyTemplateLifecycle) { +func (s *podSecurityPolicyTemplateClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyTemplateLifecycle) { sync := NewPodSecurityPolicyTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_lifecycle_adapter.go index 8335853f..ca5d7333 100644 --- a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *podSecurityPolicyTemplateLifecycleAdapter) Updated(obj runtime.Object) func NewPodSecurityPolicyTemplateLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyTemplateInterface, l PodSecurityPolicyTemplateLifecycle) PodSecurityPolicyTemplateHandlerFunc { adapter := &podSecurityPolicyTemplateLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *PodSecurityPolicyTemplate) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *PodSecurityPolicyTemplate) (*PodSecurityPolicyTemplate, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*PodSecurityPolicyTemplate); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 0614e824..89b41095 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 @@ -35,7 +35,7 @@ type PodSecurityPolicyTemplateProjectBindingList struct { Items []PodSecurityPolicyTemplateProjectBinding } -type PodSecurityPolicyTemplateProjectBindingHandlerFunc func(key string, obj *PodSecurityPolicyTemplateProjectBinding) error +type PodSecurityPolicyTemplateProjectBindingHandlerFunc func(key string, obj *PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error) type PodSecurityPolicyTemplateProjectBindingLister interface { List(namespace string, selector labels.Selector) (ret []*PodSecurityPolicyTemplateProjectBinding, err error) @@ -46,8 +46,8 @@ type PodSecurityPolicyTemplateProjectBindingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PodSecurityPolicyTemplateProjectBindingLister - AddHandler(name string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) + AddHandler(ctx context.Context, name string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type PodSecurityPolicyTemplateProjectBindingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PodSecurityPolicyTemplateProjectBindingController - AddHandler(name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) - AddLifecycle(name string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) + AddHandler(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) } type podSecurityPolicyTemplateProjectBindingLister struct { @@ -116,34 +116,27 @@ func (c *podSecurityPolicyTemplateProjectBindingController) Lister() PodSecurity } } -func (c *podSecurityPolicyTemplateProjectBindingController) AddHandler(name string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podSecurityPolicyTemplateProjectBindingController) AddHandler(ctx context.Context, name string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PodSecurityPolicyTemplateProjectBinding); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*PodSecurityPolicyTemplateProjectBinding)) }) } -func (c *podSecurityPolicyTemplateProjectBindingController) AddClusterScopedHandler(name, cluster string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *podSecurityPolicyTemplateProjectBindingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PodSecurityPolicyTemplateProjectBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PodSecurityPolicyTemplateProjectBinding); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*PodSecurityPolicyTemplateProjectBinding)) }) } @@ -238,20 +231,20 @@ func (s *podSecurityPolicyTemplateProjectBindingClient) DeleteCollection(deleteO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *podSecurityPolicyTemplateProjectBindingClient) AddHandler(name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *podSecurityPolicyTemplateProjectBindingClient) AddHandler(ctx context.Context, name string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *podSecurityPolicyTemplateProjectBindingClient) AddLifecycle(name string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) { +func (s *podSecurityPolicyTemplateProjectBindingClient) AddLifecycle(ctx context.Context, name string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) { sync := NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *podSecurityPolicyTemplateProjectBindingClient) AddClusterScopedHandler(name, clusterName string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *podSecurityPolicyTemplateProjectBindingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PodSecurityPolicyTemplateProjectBindingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *podSecurityPolicyTemplateProjectBindingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) { +func (s *podSecurityPolicyTemplateProjectBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PodSecurityPolicyTemplateProjectBindingLifecycle) { sync := NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_lifecycle_adapter.go index 5eeb9756..627ab67e 100644 --- a/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_pod_security_policy_template_project_binding_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *podSecurityPolicyTemplateProjectBindingLifecycleAdapter) Updated(obj ru func NewPodSecurityPolicyTemplateProjectBindingLifecycleAdapter(name string, clusterScoped bool, client PodSecurityPolicyTemplateProjectBindingInterface, l PodSecurityPolicyTemplateProjectBindingLifecycle) PodSecurityPolicyTemplateProjectBindingHandlerFunc { adapter := &podSecurityPolicyTemplateProjectBindingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *PodSecurityPolicyTemplateProjectBinding) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *PodSecurityPolicyTemplateProjectBinding) (*PodSecurityPolicyTemplateProjectBinding, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*PodSecurityPolicyTemplateProjectBinding); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 5e17cdce..aac16786 100644 --- a/apis/management.cattle.io/v3/zz_generated_preference_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_preference_controller.go @@ -35,7 +35,7 @@ type PreferenceList struct { Items []Preference } -type PreferenceHandlerFunc func(key string, obj *Preference) error +type PreferenceHandlerFunc func(key string, obj *Preference) (*Preference, error) type PreferenceLister interface { List(namespace string, selector labels.Selector) (ret []*Preference, err error) @@ -46,8 +46,8 @@ type PreferenceController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PreferenceLister - AddHandler(name string, handler PreferenceHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PreferenceHandlerFunc) + AddHandler(ctx context.Context, name string, handler PreferenceHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PreferenceHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type PreferenceInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PreferenceController - AddHandler(name string, sync PreferenceHandlerFunc) - AddLifecycle(name string, lifecycle PreferenceLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PreferenceHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PreferenceLifecycle) + AddHandler(ctx context.Context, name string, sync PreferenceHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PreferenceLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PreferenceHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PreferenceLifecycle) } type preferenceLister struct { @@ -116,34 +116,27 @@ func (c *preferenceController) Lister() PreferenceLister { } } -func (c *preferenceController) AddHandler(name string, handler PreferenceHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *preferenceController) AddHandler(ctx context.Context, name string, handler PreferenceHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Preference); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Preference)) }) } -func (c *preferenceController) AddClusterScopedHandler(name, cluster string, handler PreferenceHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *preferenceController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PreferenceHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Preference); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Preference)) }) } @@ -238,20 +231,20 @@ func (s *preferenceClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, li return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *preferenceClient) AddHandler(name string, sync PreferenceHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *preferenceClient) AddHandler(ctx context.Context, name string, sync PreferenceHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *preferenceClient) AddLifecycle(name string, lifecycle PreferenceLifecycle) { +func (s *preferenceClient) AddLifecycle(ctx context.Context, name string, lifecycle PreferenceLifecycle) { sync := NewPreferenceLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *preferenceClient) AddClusterScopedHandler(name, clusterName string, sync PreferenceHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *preferenceClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PreferenceHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *preferenceClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PreferenceLifecycle) { +func (s *preferenceClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PreferenceLifecycle) { sync := NewPreferenceLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_preference_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_preference_lifecycle_adapter.go index 754f42b4..9cd6fd17 100644 --- a/apis/management.cattle.io/v3/zz_generated_preference_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_preference_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *preferenceLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object func NewPreferenceLifecycleAdapter(name string, clusterScoped bool, client PreferenceInterface, l PreferenceLifecycle) PreferenceHandlerFunc { adapter := &preferenceLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Preference) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Preference) (*Preference, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Preference); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 f5cba481..6b121c2a 100644 --- a/apis/management.cattle.io/v3/zz_generated_principal_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_principal_controller.go @@ -34,7 +34,7 @@ type PrincipalList struct { Items []Principal } -type PrincipalHandlerFunc func(key string, obj *Principal) error +type PrincipalHandlerFunc func(key string, obj *Principal) (*Principal, error) type PrincipalLister interface { List(namespace string, selector labels.Selector) (ret []*Principal, err error) @@ -45,8 +45,8 @@ type PrincipalController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PrincipalLister - AddHandler(name string, handler PrincipalHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PrincipalHandlerFunc) + AddHandler(ctx context.Context, name string, handler PrincipalHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PrincipalHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type PrincipalInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PrincipalController - AddHandler(name string, sync PrincipalHandlerFunc) - AddLifecycle(name string, lifecycle PrincipalLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PrincipalHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PrincipalLifecycle) + AddHandler(ctx context.Context, name string, sync PrincipalHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PrincipalLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PrincipalHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PrincipalLifecycle) } type principalLister struct { @@ -115,34 +115,27 @@ func (c *principalController) Lister() PrincipalLister { } } -func (c *principalController) AddHandler(name string, handler PrincipalHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *principalController) AddHandler(ctx context.Context, name string, handler PrincipalHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Principal); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Principal)) }) } -func (c *principalController) AddClusterScopedHandler(name, cluster string, handler PrincipalHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *principalController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PrincipalHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Principal); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Principal)) }) } @@ -237,20 +230,20 @@ func (s *principalClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, lis return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *principalClient) AddHandler(name string, sync PrincipalHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *principalClient) AddHandler(ctx context.Context, name string, sync PrincipalHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *principalClient) AddLifecycle(name string, lifecycle PrincipalLifecycle) { +func (s *principalClient) AddLifecycle(ctx context.Context, name string, lifecycle PrincipalLifecycle) { sync := NewPrincipalLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *principalClient) AddClusterScopedHandler(name, clusterName string, sync PrincipalHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *principalClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PrincipalHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *principalClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PrincipalLifecycle) { +func (s *principalClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PrincipalLifecycle) { sync := NewPrincipalLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_principal_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_principal_lifecycle_adapter.go index f988599e..bd930ec0 100644 --- a/apis/management.cattle.io/v3/zz_generated_principal_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_principal_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *principalLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewPrincipalLifecycleAdapter(name string, clusterScoped bool, client PrincipalInterface, l PrincipalLifecycle) PrincipalHandlerFunc { adapter := &principalLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Principal) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Principal) (*Principal, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Principal); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 25125b3b..c1132510 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 @@ -35,7 +35,7 @@ type ProjectAlertList struct { Items []ProjectAlert } -type ProjectAlertHandlerFunc func(key string, obj *ProjectAlert) error +type ProjectAlertHandlerFunc func(key string, obj *ProjectAlert) (*ProjectAlert, error) type ProjectAlertLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectAlert, err error) @@ -46,8 +46,8 @@ type ProjectAlertController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ProjectAlertLister - AddHandler(name string, handler ProjectAlertHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ProjectAlertHandlerFunc) + AddHandler(ctx context.Context, name string, handler ProjectAlertHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectAlertHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ProjectAlertInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ProjectAlertController - AddHandler(name string, sync ProjectAlertHandlerFunc) - AddLifecycle(name string, lifecycle ProjectAlertLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ProjectAlertHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectAlertLifecycle) + AddHandler(ctx context.Context, name string, sync ProjectAlertHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ProjectAlertLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectAlertHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectAlertLifecycle) } type projectAlertLister struct { @@ -116,34 +116,27 @@ func (c *projectAlertController) Lister() ProjectAlertLister { } } -func (c *projectAlertController) AddHandler(name string, handler ProjectAlertHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectAlertController) AddHandler(ctx context.Context, name string, handler ProjectAlertHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectAlert); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ProjectAlert)) }) } -func (c *projectAlertController) AddClusterScopedHandler(name, cluster string, handler ProjectAlertHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectAlertController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ProjectAlertHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectAlert); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ProjectAlert)) }) } @@ -238,20 +231,20 @@ func (s *projectAlertClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *projectAlertClient) AddHandler(name string, sync ProjectAlertHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *projectAlertClient) AddHandler(ctx context.Context, name string, sync ProjectAlertHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectAlertClient) AddLifecycle(name string, lifecycle ProjectAlertLifecycle) { +func (s *projectAlertClient) AddLifecycle(ctx context.Context, name string, lifecycle ProjectAlertLifecycle) { sync := NewProjectAlertLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectAlertClient) AddClusterScopedHandler(name, clusterName string, sync ProjectAlertHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *projectAlertClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectAlertHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *projectAlertClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectAlertLifecycle) { +func (s *projectAlertClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectAlertLifecycle) { sync := NewProjectAlertLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_project_alert_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_project_alert_lifecycle_adapter.go index 93ccc96e..5f8a388b 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_alert_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_project_alert_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *projectAlertLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obje func NewProjectAlertLifecycleAdapter(name string, clusterScoped bool, client ProjectAlertInterface, l ProjectAlertLifecycle) ProjectAlertHandlerFunc { adapter := &projectAlertLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ProjectAlert) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ProjectAlert) (*ProjectAlert, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ProjectAlert); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 775e2a53..0f648ee3 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 @@ -35,7 +35,7 @@ type ProjectCatalogList struct { Items []ProjectCatalog } -type ProjectCatalogHandlerFunc func(key string, obj *ProjectCatalog) error +type ProjectCatalogHandlerFunc func(key string, obj *ProjectCatalog) (*ProjectCatalog, error) type ProjectCatalogLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectCatalog, err error) @@ -46,8 +46,8 @@ type ProjectCatalogController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ProjectCatalogLister - AddHandler(name string, handler ProjectCatalogHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ProjectCatalogHandlerFunc) + AddHandler(ctx context.Context, name string, handler ProjectCatalogHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectCatalogHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ProjectCatalogInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ProjectCatalogController - AddHandler(name string, sync ProjectCatalogHandlerFunc) - AddLifecycle(name string, lifecycle ProjectCatalogLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ProjectCatalogHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectCatalogLifecycle) + AddHandler(ctx context.Context, name string, sync ProjectCatalogHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ProjectCatalogLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectCatalogHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectCatalogLifecycle) } type projectCatalogLister struct { @@ -116,34 +116,27 @@ func (c *projectCatalogController) Lister() ProjectCatalogLister { } } -func (c *projectCatalogController) AddHandler(name string, handler ProjectCatalogHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectCatalogController) AddHandler(ctx context.Context, name string, handler ProjectCatalogHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectCatalog); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ProjectCatalog)) }) } -func (c *projectCatalogController) AddClusterScopedHandler(name, cluster string, handler ProjectCatalogHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectCatalogController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ProjectCatalogHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectCatalog); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ProjectCatalog)) }) } @@ -238,20 +231,20 @@ func (s *projectCatalogClient) DeleteCollection(deleteOpts *metav1.DeleteOptions return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *projectCatalogClient) AddHandler(name string, sync ProjectCatalogHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *projectCatalogClient) AddHandler(ctx context.Context, name string, sync ProjectCatalogHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectCatalogClient) AddLifecycle(name string, lifecycle ProjectCatalogLifecycle) { +func (s *projectCatalogClient) AddLifecycle(ctx context.Context, name string, lifecycle ProjectCatalogLifecycle) { sync := NewProjectCatalogLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectCatalogClient) AddClusterScopedHandler(name, clusterName string, sync ProjectCatalogHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *projectCatalogClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectCatalogHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *projectCatalogClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectCatalogLifecycle) { +func (s *projectCatalogClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectCatalogLifecycle) { sync := NewProjectCatalogLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_project_catalog_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_project_catalog_lifecycle_adapter.go index 86316f01..7bf5a9f7 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_catalog_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_project_catalog_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *projectCatalogLifecycleAdapter) Updated(obj runtime.Object) (runtime.Ob func NewProjectCatalogLifecycleAdapter(name string, clusterScoped bool, client ProjectCatalogInterface, l ProjectCatalogLifecycle) ProjectCatalogHandlerFunc { adapter := &projectCatalogLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ProjectCatalog) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ProjectCatalog) (*ProjectCatalog, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ProjectCatalog); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 7021c161..de62ba55 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_project_controller.go @@ -35,7 +35,7 @@ type ProjectList struct { Items []Project } -type ProjectHandlerFunc func(key string, obj *Project) error +type ProjectHandlerFunc func(key string, obj *Project) (*Project, error) type ProjectLister interface { List(namespace string, selector labels.Selector) (ret []*Project, err error) @@ -46,8 +46,8 @@ type ProjectController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ProjectLister - AddHandler(name string, handler ProjectHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ProjectHandlerFunc) + AddHandler(ctx context.Context, name string, handler ProjectHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ProjectInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ProjectController - AddHandler(name string, sync ProjectHandlerFunc) - AddLifecycle(name string, lifecycle ProjectLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ProjectHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectLifecycle) + AddHandler(ctx context.Context, name string, sync ProjectHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ProjectLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectLifecycle) } type projectLister struct { @@ -116,34 +116,27 @@ func (c *projectController) Lister() ProjectLister { } } -func (c *projectController) AddHandler(name string, handler ProjectHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectController) AddHandler(ctx context.Context, name string, handler ProjectHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Project); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Project)) }) } -func (c *projectController) AddClusterScopedHandler(name, cluster string, handler ProjectHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ProjectHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Project); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Project)) }) } @@ -238,20 +231,20 @@ func (s *projectClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *projectClient) AddHandler(name string, sync ProjectHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *projectClient) AddHandler(ctx context.Context, name string, sync ProjectHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectClient) AddLifecycle(name string, lifecycle ProjectLifecycle) { +func (s *projectClient) AddLifecycle(ctx context.Context, name string, lifecycle ProjectLifecycle) { sync := NewProjectLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectClient) AddClusterScopedHandler(name, clusterName string, sync ProjectHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *projectClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *projectClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectLifecycle) { +func (s *projectClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectLifecycle) { sync := NewProjectLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_project_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_project_lifecycle_adapter.go index d997fb8a..4b3a480c 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_project_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *projectLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewProjectLifecycleAdapter(name string, clusterScoped bool, client ProjectInterface, l ProjectLifecycle) ProjectHandlerFunc { adapter := &projectLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Project) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Project) (*Project, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Project); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 5d712ba4..b273ac63 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 @@ -35,7 +35,7 @@ type ProjectLoggingList struct { Items []ProjectLogging } -type ProjectLoggingHandlerFunc func(key string, obj *ProjectLogging) error +type ProjectLoggingHandlerFunc func(key string, obj *ProjectLogging) (*ProjectLogging, error) type ProjectLoggingLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectLogging, err error) @@ -46,8 +46,8 @@ type ProjectLoggingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ProjectLoggingLister - AddHandler(name string, handler ProjectLoggingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ProjectLoggingHandlerFunc) + AddHandler(ctx context.Context, name string, handler ProjectLoggingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectLoggingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ProjectLoggingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ProjectLoggingController - AddHandler(name string, sync ProjectLoggingHandlerFunc) - AddLifecycle(name string, lifecycle ProjectLoggingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ProjectLoggingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectLoggingLifecycle) + AddHandler(ctx context.Context, name string, sync ProjectLoggingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ProjectLoggingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectLoggingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectLoggingLifecycle) } type projectLoggingLister struct { @@ -116,34 +116,27 @@ func (c *projectLoggingController) Lister() ProjectLoggingLister { } } -func (c *projectLoggingController) AddHandler(name string, handler ProjectLoggingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectLoggingController) AddHandler(ctx context.Context, name string, handler ProjectLoggingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectLogging); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ProjectLogging)) }) } -func (c *projectLoggingController) AddClusterScopedHandler(name, cluster string, handler ProjectLoggingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectLoggingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ProjectLoggingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectLogging); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ProjectLogging)) }) } @@ -238,20 +231,20 @@ func (s *projectLoggingClient) DeleteCollection(deleteOpts *metav1.DeleteOptions return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *projectLoggingClient) AddHandler(name string, sync ProjectLoggingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *projectLoggingClient) AddHandler(ctx context.Context, name string, sync ProjectLoggingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectLoggingClient) AddLifecycle(name string, lifecycle ProjectLoggingLifecycle) { +func (s *projectLoggingClient) AddLifecycle(ctx context.Context, name string, lifecycle ProjectLoggingLifecycle) { sync := NewProjectLoggingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectLoggingClient) AddClusterScopedHandler(name, clusterName string, sync ProjectLoggingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *projectLoggingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectLoggingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *projectLoggingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectLoggingLifecycle) { +func (s *projectLoggingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectLoggingLifecycle) { sync := NewProjectLoggingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_project_logging_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_project_logging_lifecycle_adapter.go index 0b561395..f99121ec 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_logging_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_project_logging_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *projectLoggingLifecycleAdapter) Updated(obj runtime.Object) (runtime.Ob func NewProjectLoggingLifecycleAdapter(name string, clusterScoped bool, client ProjectLoggingInterface, l ProjectLoggingLifecycle) ProjectLoggingHandlerFunc { adapter := &projectLoggingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ProjectLogging) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ProjectLogging) (*ProjectLogging, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ProjectLogging); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 4f8d1c8a..11fedc8b 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 @@ -35,7 +35,7 @@ type ProjectNetworkPolicyList struct { Items []ProjectNetworkPolicy } -type ProjectNetworkPolicyHandlerFunc func(key string, obj *ProjectNetworkPolicy) error +type ProjectNetworkPolicyHandlerFunc func(key string, obj *ProjectNetworkPolicy) (*ProjectNetworkPolicy, error) type ProjectNetworkPolicyLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectNetworkPolicy, err error) @@ -46,8 +46,8 @@ type ProjectNetworkPolicyController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ProjectNetworkPolicyLister - AddHandler(name string, handler ProjectNetworkPolicyHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ProjectNetworkPolicyHandlerFunc) + AddHandler(ctx context.Context, name string, handler ProjectNetworkPolicyHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectNetworkPolicyHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ProjectNetworkPolicyInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ProjectNetworkPolicyController - AddHandler(name string, sync ProjectNetworkPolicyHandlerFunc) - AddLifecycle(name string, lifecycle ProjectNetworkPolicyLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ProjectNetworkPolicyHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectNetworkPolicyLifecycle) + AddHandler(ctx context.Context, name string, sync ProjectNetworkPolicyHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ProjectNetworkPolicyLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectNetworkPolicyHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectNetworkPolicyLifecycle) } type projectNetworkPolicyLister struct { @@ -116,34 +116,27 @@ func (c *projectNetworkPolicyController) Lister() ProjectNetworkPolicyLister { } } -func (c *projectNetworkPolicyController) AddHandler(name string, handler ProjectNetworkPolicyHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectNetworkPolicyController) AddHandler(ctx context.Context, name string, handler ProjectNetworkPolicyHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectNetworkPolicy); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ProjectNetworkPolicy)) }) } -func (c *projectNetworkPolicyController) AddClusterScopedHandler(name, cluster string, handler ProjectNetworkPolicyHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectNetworkPolicyController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ProjectNetworkPolicyHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectNetworkPolicy); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ProjectNetworkPolicy)) }) } @@ -238,20 +231,20 @@ func (s *projectNetworkPolicyClient) DeleteCollection(deleteOpts *metav1.DeleteO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *projectNetworkPolicyClient) AddHandler(name string, sync ProjectNetworkPolicyHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *projectNetworkPolicyClient) AddHandler(ctx context.Context, name string, sync ProjectNetworkPolicyHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectNetworkPolicyClient) AddLifecycle(name string, lifecycle ProjectNetworkPolicyLifecycle) { +func (s *projectNetworkPolicyClient) AddLifecycle(ctx context.Context, name string, lifecycle ProjectNetworkPolicyLifecycle) { sync := NewProjectNetworkPolicyLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectNetworkPolicyClient) AddClusterScopedHandler(name, clusterName string, sync ProjectNetworkPolicyHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *projectNetworkPolicyClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectNetworkPolicyHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *projectNetworkPolicyClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectNetworkPolicyLifecycle) { +func (s *projectNetworkPolicyClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectNetworkPolicyLifecycle) { sync := NewProjectNetworkPolicyLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_project_network_policy_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_project_network_policy_lifecycle_adapter.go index 0ac47e84..ecfa78bf 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_network_policy_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_project_network_policy_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *projectNetworkPolicyLifecycleAdapter) Updated(obj runtime.Object) (runt func NewProjectNetworkPolicyLifecycleAdapter(name string, clusterScoped bool, client ProjectNetworkPolicyInterface, l ProjectNetworkPolicyLifecycle) ProjectNetworkPolicyHandlerFunc { adapter := &projectNetworkPolicyLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ProjectNetworkPolicy) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ProjectNetworkPolicy) (*ProjectNetworkPolicy, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ProjectNetworkPolicy); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 45bad8c0..b30aacbd 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 @@ -35,7 +35,7 @@ type ProjectRoleTemplateBindingList struct { Items []ProjectRoleTemplateBinding } -type ProjectRoleTemplateBindingHandlerFunc func(key string, obj *ProjectRoleTemplateBinding) error +type ProjectRoleTemplateBindingHandlerFunc func(key string, obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error) type ProjectRoleTemplateBindingLister interface { List(namespace string, selector labels.Selector) (ret []*ProjectRoleTemplateBinding, err error) @@ -46,8 +46,8 @@ type ProjectRoleTemplateBindingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ProjectRoleTemplateBindingLister - AddHandler(name string, handler ProjectRoleTemplateBindingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ProjectRoleTemplateBindingHandlerFunc) + AddHandler(ctx context.Context, name string, handler ProjectRoleTemplateBindingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ProjectRoleTemplateBindingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ProjectRoleTemplateBindingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ProjectRoleTemplateBindingController - AddHandler(name string, sync ProjectRoleTemplateBindingHandlerFunc) - AddLifecycle(name string, lifecycle ProjectRoleTemplateBindingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ProjectRoleTemplateBindingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectRoleTemplateBindingLifecycle) + AddHandler(ctx context.Context, name string, sync ProjectRoleTemplateBindingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ProjectRoleTemplateBindingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectRoleTemplateBindingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectRoleTemplateBindingLifecycle) } type projectRoleTemplateBindingLister struct { @@ -116,34 +116,27 @@ func (c *projectRoleTemplateBindingController) Lister() ProjectRoleTemplateBindi } } -func (c *projectRoleTemplateBindingController) AddHandler(name string, handler ProjectRoleTemplateBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectRoleTemplateBindingController) AddHandler(ctx context.Context, name string, handler ProjectRoleTemplateBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectRoleTemplateBinding); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ProjectRoleTemplateBinding)) }) } -func (c *projectRoleTemplateBindingController) AddClusterScopedHandler(name, cluster string, handler ProjectRoleTemplateBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *projectRoleTemplateBindingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ProjectRoleTemplateBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ProjectRoleTemplateBinding); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ProjectRoleTemplateBinding)) }) } @@ -238,20 +231,20 @@ func (s *projectRoleTemplateBindingClient) DeleteCollection(deleteOpts *metav1.D return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *projectRoleTemplateBindingClient) AddHandler(name string, sync ProjectRoleTemplateBindingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *projectRoleTemplateBindingClient) AddHandler(ctx context.Context, name string, sync ProjectRoleTemplateBindingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectRoleTemplateBindingClient) AddLifecycle(name string, lifecycle ProjectRoleTemplateBindingLifecycle) { +func (s *projectRoleTemplateBindingClient) AddLifecycle(ctx context.Context, name string, lifecycle ProjectRoleTemplateBindingLifecycle) { sync := NewProjectRoleTemplateBindingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *projectRoleTemplateBindingClient) AddClusterScopedHandler(name, clusterName string, sync ProjectRoleTemplateBindingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *projectRoleTemplateBindingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ProjectRoleTemplateBindingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *projectRoleTemplateBindingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ProjectRoleTemplateBindingLifecycle) { +func (s *projectRoleTemplateBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ProjectRoleTemplateBindingLifecycle) { sync := NewProjectRoleTemplateBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_lifecycle_adapter.go index ac92f5e1..be227eaa 100644 --- a/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_project_role_template_binding_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *projectRoleTemplateBindingLifecycleAdapter) Updated(obj runtime.Object) func NewProjectRoleTemplateBindingLifecycleAdapter(name string, clusterScoped bool, client ProjectRoleTemplateBindingInterface, l ProjectRoleTemplateBindingLifecycle) ProjectRoleTemplateBindingHandlerFunc { adapter := &projectRoleTemplateBindingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ProjectRoleTemplateBinding) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ProjectRoleTemplateBinding) (*ProjectRoleTemplateBinding, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ProjectRoleTemplateBinding); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 e36ecaca..47f79272 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 @@ -34,7 +34,7 @@ type RoleTemplateList struct { Items []RoleTemplate } -type RoleTemplateHandlerFunc func(key string, obj *RoleTemplate) error +type RoleTemplateHandlerFunc func(key string, obj *RoleTemplate) (*RoleTemplate, error) type RoleTemplateLister interface { List(namespace string, selector labels.Selector) (ret []*RoleTemplate, err error) @@ -45,8 +45,8 @@ type RoleTemplateController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() RoleTemplateLister - AddHandler(name string, handler RoleTemplateHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler RoleTemplateHandlerFunc) + AddHandler(ctx context.Context, name string, handler RoleTemplateHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RoleTemplateHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type RoleTemplateInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() RoleTemplateController - AddHandler(name string, sync RoleTemplateHandlerFunc) - AddLifecycle(name string, lifecycle RoleTemplateLifecycle) - AddClusterScopedHandler(name, clusterName string, sync RoleTemplateHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle RoleTemplateLifecycle) + AddHandler(ctx context.Context, name string, sync RoleTemplateHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle RoleTemplateLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleTemplateHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleTemplateLifecycle) } type roleTemplateLister struct { @@ -115,34 +115,27 @@ func (c *roleTemplateController) Lister() RoleTemplateLister { } } -func (c *roleTemplateController) AddHandler(name string, handler RoleTemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *roleTemplateController) AddHandler(ctx context.Context, name string, handler RoleTemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*RoleTemplate); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*RoleTemplate)) }) } -func (c *roleTemplateController) AddClusterScopedHandler(name, cluster string, handler RoleTemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *roleTemplateController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler RoleTemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*RoleTemplate); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*RoleTemplate)) }) } @@ -237,20 +230,20 @@ func (s *roleTemplateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *roleTemplateClient) AddHandler(name string, sync RoleTemplateHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *roleTemplateClient) AddHandler(ctx context.Context, name string, sync RoleTemplateHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *roleTemplateClient) AddLifecycle(name string, lifecycle RoleTemplateLifecycle) { +func (s *roleTemplateClient) AddLifecycle(ctx context.Context, name string, lifecycle RoleTemplateLifecycle) { sync := NewRoleTemplateLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *roleTemplateClient) AddClusterScopedHandler(name, clusterName string, sync RoleTemplateHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *roleTemplateClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleTemplateHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *roleTemplateClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle RoleTemplateLifecycle) { +func (s *roleTemplateClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleTemplateLifecycle) { sync := NewRoleTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_role_template_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_role_template_lifecycle_adapter.go index 3027ce94..37c545f8 100644 --- a/apis/management.cattle.io/v3/zz_generated_role_template_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_role_template_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *roleTemplateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obje func NewRoleTemplateLifecycleAdapter(name string, clusterScoped bool, client RoleTemplateInterface, l RoleTemplateLifecycle) RoleTemplateHandlerFunc { adapter := &roleTemplateLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *RoleTemplate) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *RoleTemplate) (*RoleTemplate, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*RoleTemplate); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 8388c43d..e0133dae 100644 --- a/apis/management.cattle.io/v3/zz_generated_setting_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_setting_controller.go @@ -34,7 +34,7 @@ type SettingList struct { Items []Setting } -type SettingHandlerFunc func(key string, obj *Setting) error +type SettingHandlerFunc func(key string, obj *Setting) (*Setting, error) type SettingLister interface { List(namespace string, selector labels.Selector) (ret []*Setting, err error) @@ -45,8 +45,8 @@ type SettingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SettingLister - AddHandler(name string, handler SettingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SettingHandlerFunc) + AddHandler(ctx context.Context, name string, handler SettingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SettingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type SettingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SettingController - AddHandler(name string, sync SettingHandlerFunc) - AddLifecycle(name string, lifecycle SettingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SettingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SettingLifecycle) + AddHandler(ctx context.Context, name string, sync SettingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SettingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SettingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SettingLifecycle) } type settingLister struct { @@ -115,34 +115,27 @@ func (c *settingController) Lister() SettingLister { } } -func (c *settingController) AddHandler(name string, handler SettingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *settingController) AddHandler(ctx context.Context, name string, handler SettingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Setting); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Setting)) }) } -func (c *settingController) AddClusterScopedHandler(name, cluster string, handler SettingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *settingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SettingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Setting); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Setting)) }) } @@ -237,20 +230,20 @@ func (s *settingClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *settingClient) AddHandler(name string, sync SettingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *settingClient) AddHandler(ctx context.Context, name string, sync SettingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *settingClient) AddLifecycle(name string, lifecycle SettingLifecycle) { +func (s *settingClient) AddLifecycle(ctx context.Context, name string, lifecycle SettingLifecycle) { sync := NewSettingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *settingClient) AddClusterScopedHandler(name, clusterName string, sync SettingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *settingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SettingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *settingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SettingLifecycle) { +func (s *settingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SettingLifecycle) { sync := NewSettingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_setting_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_setting_lifecycle_adapter.go index 9dddd7fc..e4ebaacb 100644 --- a/apis/management.cattle.io/v3/zz_generated_setting_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_setting_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *settingLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewSettingLifecycleAdapter(name string, clusterScoped bool, client SettingInterface, l SettingLifecycle) SettingHandlerFunc { adapter := &settingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Setting) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Setting) (*Setting, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Setting); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 ebc4a14c..a8a863ca 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 @@ -34,7 +34,7 @@ type TemplateContentList struct { Items []TemplateContent } -type TemplateContentHandlerFunc func(key string, obj *TemplateContent) error +type TemplateContentHandlerFunc func(key string, obj *TemplateContent) (*TemplateContent, error) type TemplateContentLister interface { List(namespace string, selector labels.Selector) (ret []*TemplateContent, err error) @@ -45,8 +45,8 @@ type TemplateContentController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() TemplateContentLister - AddHandler(name string, handler TemplateContentHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler TemplateContentHandlerFunc) + AddHandler(ctx context.Context, name string, handler TemplateContentHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TemplateContentHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type TemplateContentInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() TemplateContentController - AddHandler(name string, sync TemplateContentHandlerFunc) - AddLifecycle(name string, lifecycle TemplateContentLifecycle) - AddClusterScopedHandler(name, clusterName string, sync TemplateContentHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle TemplateContentLifecycle) + AddHandler(ctx context.Context, name string, sync TemplateContentHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle TemplateContentLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateContentHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateContentLifecycle) } type templateContentLister struct { @@ -115,34 +115,27 @@ func (c *templateContentController) Lister() TemplateContentLister { } } -func (c *templateContentController) AddHandler(name string, handler TemplateContentHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *templateContentController) AddHandler(ctx context.Context, name string, handler TemplateContentHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*TemplateContent); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*TemplateContent)) }) } -func (c *templateContentController) AddClusterScopedHandler(name, cluster string, handler TemplateContentHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *templateContentController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler TemplateContentHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*TemplateContent); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*TemplateContent)) }) } @@ -237,20 +230,20 @@ func (s *templateContentClient) DeleteCollection(deleteOpts *metav1.DeleteOption return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *templateContentClient) AddHandler(name string, sync TemplateContentHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *templateContentClient) AddHandler(ctx context.Context, name string, sync TemplateContentHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *templateContentClient) AddLifecycle(name string, lifecycle TemplateContentLifecycle) { +func (s *templateContentClient) AddLifecycle(ctx context.Context, name string, lifecycle TemplateContentLifecycle) { sync := NewTemplateContentLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *templateContentClient) AddClusterScopedHandler(name, clusterName string, sync TemplateContentHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *templateContentClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateContentHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *templateContentClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle TemplateContentLifecycle) { +func (s *templateContentClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateContentLifecycle) { sync := NewTemplateContentLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_template_content_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_template_content_lifecycle_adapter.go index 83cf95bd..2dcdacb8 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_content_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_template_content_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *templateContentLifecycleAdapter) Updated(obj runtime.Object) (runtime.O func NewTemplateContentLifecycleAdapter(name string, clusterScoped bool, client TemplateContentInterface, l TemplateContentLifecycle) TemplateContentHandlerFunc { adapter := &templateContentLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *TemplateContent) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *TemplateContent) (*TemplateContent, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*TemplateContent); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 79c4af9b..6db8b23c 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_template_controller.go @@ -34,7 +34,7 @@ type TemplateList struct { Items []Template } -type TemplateHandlerFunc func(key string, obj *Template) error +type TemplateHandlerFunc func(key string, obj *Template) (*Template, error) type TemplateLister interface { List(namespace string, selector labels.Selector) (ret []*Template, err error) @@ -45,8 +45,8 @@ type TemplateController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() TemplateLister - AddHandler(name string, handler TemplateHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler TemplateHandlerFunc) + AddHandler(ctx context.Context, name string, handler TemplateHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TemplateHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type TemplateInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() TemplateController - AddHandler(name string, sync TemplateHandlerFunc) - AddLifecycle(name string, lifecycle TemplateLifecycle) - AddClusterScopedHandler(name, clusterName string, sync TemplateHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle TemplateLifecycle) + AddHandler(ctx context.Context, name string, sync TemplateHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle TemplateLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateLifecycle) } type templateLister struct { @@ -115,34 +115,27 @@ func (c *templateController) Lister() TemplateLister { } } -func (c *templateController) AddHandler(name string, handler TemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *templateController) AddHandler(ctx context.Context, name string, handler TemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Template); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Template)) }) } -func (c *templateController) AddClusterScopedHandler(name, cluster string, handler TemplateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *templateController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler TemplateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Template); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Template)) }) } @@ -237,20 +230,20 @@ func (s *templateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, list return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *templateClient) AddHandler(name string, sync TemplateHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *templateClient) AddHandler(ctx context.Context, name string, sync TemplateHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *templateClient) AddLifecycle(name string, lifecycle TemplateLifecycle) { +func (s *templateClient) AddLifecycle(ctx context.Context, name string, lifecycle TemplateLifecycle) { sync := NewTemplateLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *templateClient) AddClusterScopedHandler(name, clusterName string, sync TemplateHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *templateClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *templateClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle TemplateLifecycle) { +func (s *templateClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateLifecycle) { sync := NewTemplateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_template_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_template_lifecycle_adapter.go index 6e9cc4b7..f3c6c878 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_template_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *templateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewTemplateLifecycleAdapter(name string, clusterScoped bool, client TemplateInterface, l TemplateLifecycle) TemplateHandlerFunc { adapter := &templateLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Template) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Template) (*Template, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Template); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 1aaec1d5..bc3e01fa 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 @@ -34,7 +34,7 @@ type TemplateVersionList struct { Items []TemplateVersion } -type TemplateVersionHandlerFunc func(key string, obj *TemplateVersion) error +type TemplateVersionHandlerFunc func(key string, obj *TemplateVersion) (*TemplateVersion, error) type TemplateVersionLister interface { List(namespace string, selector labels.Selector) (ret []*TemplateVersion, err error) @@ -45,8 +45,8 @@ type TemplateVersionController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() TemplateVersionLister - AddHandler(name string, handler TemplateVersionHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler TemplateVersionHandlerFunc) + AddHandler(ctx context.Context, name string, handler TemplateVersionHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TemplateVersionHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type TemplateVersionInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() TemplateVersionController - AddHandler(name string, sync TemplateVersionHandlerFunc) - AddLifecycle(name string, lifecycle TemplateVersionLifecycle) - AddClusterScopedHandler(name, clusterName string, sync TemplateVersionHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle TemplateVersionLifecycle) + AddHandler(ctx context.Context, name string, sync TemplateVersionHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle TemplateVersionLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateVersionHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateVersionLifecycle) } type templateVersionLister struct { @@ -115,34 +115,27 @@ func (c *templateVersionController) Lister() TemplateVersionLister { } } -func (c *templateVersionController) AddHandler(name string, handler TemplateVersionHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *templateVersionController) AddHandler(ctx context.Context, name string, handler TemplateVersionHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*TemplateVersion); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*TemplateVersion)) }) } -func (c *templateVersionController) AddClusterScopedHandler(name, cluster string, handler TemplateVersionHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *templateVersionController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler TemplateVersionHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*TemplateVersion); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*TemplateVersion)) }) } @@ -237,20 +230,20 @@ func (s *templateVersionClient) DeleteCollection(deleteOpts *metav1.DeleteOption return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *templateVersionClient) AddHandler(name string, sync TemplateVersionHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *templateVersionClient) AddHandler(ctx context.Context, name string, sync TemplateVersionHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *templateVersionClient) AddLifecycle(name string, lifecycle TemplateVersionLifecycle) { +func (s *templateVersionClient) AddLifecycle(ctx context.Context, name string, lifecycle TemplateVersionLifecycle) { sync := NewTemplateVersionLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *templateVersionClient) AddClusterScopedHandler(name, clusterName string, sync TemplateVersionHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *templateVersionClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TemplateVersionHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *templateVersionClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle TemplateVersionLifecycle) { +func (s *templateVersionClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TemplateVersionLifecycle) { sync := NewTemplateVersionLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_template_version_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_template_version_lifecycle_adapter.go index deb14015..30989d84 100644 --- a/apis/management.cattle.io/v3/zz_generated_template_version_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_template_version_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *templateVersionLifecycleAdapter) Updated(obj runtime.Object) (runtime.O func NewTemplateVersionLifecycleAdapter(name string, clusterScoped bool, client TemplateVersionInterface, l TemplateVersionLifecycle) TemplateVersionHandlerFunc { adapter := &templateVersionLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *TemplateVersion) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *TemplateVersion) (*TemplateVersion, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*TemplateVersion); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 ed4c1fd5..a2f4d580 100644 --- a/apis/management.cattle.io/v3/zz_generated_token_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_token_controller.go @@ -34,7 +34,7 @@ type TokenList struct { Items []Token } -type TokenHandlerFunc func(key string, obj *Token) error +type TokenHandlerFunc func(key string, obj *Token) (*Token, error) type TokenLister interface { List(namespace string, selector labels.Selector) (ret []*Token, err error) @@ -45,8 +45,8 @@ type TokenController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() TokenLister - AddHandler(name string, handler TokenHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler TokenHandlerFunc) + AddHandler(ctx context.Context, name string, handler TokenHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler TokenHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type TokenInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() TokenController - AddHandler(name string, sync TokenHandlerFunc) - AddLifecycle(name string, lifecycle TokenLifecycle) - AddClusterScopedHandler(name, clusterName string, sync TokenHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle TokenLifecycle) + AddHandler(ctx context.Context, name string, sync TokenHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle TokenLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TokenHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TokenLifecycle) } type tokenLister struct { @@ -115,34 +115,27 @@ func (c *tokenController) Lister() TokenLister { } } -func (c *tokenController) AddHandler(name string, handler TokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *tokenController) AddHandler(ctx context.Context, name string, handler TokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Token); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Token)) }) } -func (c *tokenController) AddClusterScopedHandler(name, cluster string, handler TokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *tokenController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler TokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Token); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Token)) }) } @@ -237,20 +230,20 @@ func (s *tokenClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpt return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *tokenClient) AddHandler(name string, sync TokenHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *tokenClient) AddHandler(ctx context.Context, name string, sync TokenHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *tokenClient) AddLifecycle(name string, lifecycle TokenLifecycle) { +func (s *tokenClient) AddLifecycle(ctx context.Context, name string, lifecycle TokenLifecycle) { sync := NewTokenLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *tokenClient) AddClusterScopedHandler(name, clusterName string, sync TokenHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *tokenClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync TokenHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *tokenClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle TokenLifecycle) { +func (s *tokenClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle TokenLifecycle) { sync := NewTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_token_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_token_lifecycle_adapter.go index 23e6f1f3..72fe9575 100644 --- a/apis/management.cattle.io/v3/zz_generated_token_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_token_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *tokenLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, err func NewTokenLifecycleAdapter(name string, clusterScoped bool, client TokenInterface, l TokenLifecycle) TokenHandlerFunc { adapter := &tokenLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Token) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Token) (*Token, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Token); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 bfed1cb9..914f77ce 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 @@ -34,7 +34,7 @@ type UserAttributeList struct { Items []UserAttribute } -type UserAttributeHandlerFunc func(key string, obj *UserAttribute) error +type UserAttributeHandlerFunc func(key string, obj *UserAttribute) (*UserAttribute, error) type UserAttributeLister interface { List(namespace string, selector labels.Selector) (ret []*UserAttribute, err error) @@ -45,8 +45,8 @@ type UserAttributeController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() UserAttributeLister - AddHandler(name string, handler UserAttributeHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler UserAttributeHandlerFunc) + AddHandler(ctx context.Context, name string, handler UserAttributeHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler UserAttributeHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type UserAttributeInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() UserAttributeController - AddHandler(name string, sync UserAttributeHandlerFunc) - AddLifecycle(name string, lifecycle UserAttributeLifecycle) - AddClusterScopedHandler(name, clusterName string, sync UserAttributeHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle UserAttributeLifecycle) + AddHandler(ctx context.Context, name string, sync UserAttributeHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle UserAttributeLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync UserAttributeHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle UserAttributeLifecycle) } type userAttributeLister struct { @@ -115,34 +115,27 @@ func (c *userAttributeController) Lister() UserAttributeLister { } } -func (c *userAttributeController) AddHandler(name string, handler UserAttributeHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *userAttributeController) AddHandler(ctx context.Context, name string, handler UserAttributeHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*UserAttribute); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*UserAttribute)) }) } -func (c *userAttributeController) AddClusterScopedHandler(name, cluster string, handler UserAttributeHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *userAttributeController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler UserAttributeHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*UserAttribute); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*UserAttribute)) }) } @@ -237,20 +230,20 @@ func (s *userAttributeClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *userAttributeClient) AddHandler(name string, sync UserAttributeHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *userAttributeClient) AddHandler(ctx context.Context, name string, sync UserAttributeHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *userAttributeClient) AddLifecycle(name string, lifecycle UserAttributeLifecycle) { +func (s *userAttributeClient) AddLifecycle(ctx context.Context, name string, lifecycle UserAttributeLifecycle) { sync := NewUserAttributeLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *userAttributeClient) AddClusterScopedHandler(name, clusterName string, sync UserAttributeHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *userAttributeClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync UserAttributeHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *userAttributeClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle UserAttributeLifecycle) { +func (s *userAttributeClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle UserAttributeLifecycle) { sync := NewUserAttributeLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_user_attribute_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_user_attribute_lifecycle_adapter.go index 04050120..c14b395b 100644 --- a/apis/management.cattle.io/v3/zz_generated_user_attribute_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_user_attribute_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *userAttributeLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obj func NewUserAttributeLifecycleAdapter(name string, clusterScoped bool, client UserAttributeInterface, l UserAttributeLifecycle) UserAttributeHandlerFunc { adapter := &userAttributeLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *UserAttribute) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *UserAttribute) (*UserAttribute, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*UserAttribute); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 f791059a..67963a3d 100644 --- a/apis/management.cattle.io/v3/zz_generated_user_controller.go +++ b/apis/management.cattle.io/v3/zz_generated_user_controller.go @@ -34,7 +34,7 @@ type UserList struct { Items []User } -type UserHandlerFunc func(key string, obj *User) error +type UserHandlerFunc func(key string, obj *User) (*User, error) type UserLister interface { List(namespace string, selector labels.Selector) (ret []*User, err error) @@ -45,8 +45,8 @@ type UserController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() UserLister - AddHandler(name string, handler UserHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler UserHandlerFunc) + AddHandler(ctx context.Context, name string, handler UserHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler UserHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type UserInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() UserController - AddHandler(name string, sync UserHandlerFunc) - AddLifecycle(name string, lifecycle UserLifecycle) - AddClusterScopedHandler(name, clusterName string, sync UserHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle UserLifecycle) + AddHandler(ctx context.Context, name string, sync UserHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle UserLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync UserHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle UserLifecycle) } type userLister struct { @@ -115,34 +115,27 @@ func (c *userController) Lister() UserLister { } } -func (c *userController) AddHandler(name string, handler UserHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *userController) AddHandler(ctx context.Context, name string, handler UserHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*User); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*User)) }) } -func (c *userController) AddClusterScopedHandler(name, cluster string, handler UserHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *userController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler UserHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*User); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*User)) }) } @@ -237,20 +230,20 @@ func (s *userClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *userClient) AddHandler(name string, sync UserHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *userClient) AddHandler(ctx context.Context, name string, sync UserHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *userClient) AddLifecycle(name string, lifecycle UserLifecycle) { +func (s *userClient) AddLifecycle(ctx context.Context, name string, lifecycle UserLifecycle) { sync := NewUserLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *userClient) AddClusterScopedHandler(name, clusterName string, sync UserHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *userClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync UserHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *userClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle UserLifecycle) { +func (s *userClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle UserLifecycle) { sync := NewUserLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3/zz_generated_user_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_user_lifecycle_adapter.go index 393e2e16..75f036a4 100644 --- a/apis/management.cattle.io/v3/zz_generated_user_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3/zz_generated_user_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *userLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, erro func NewUserLifecycleAdapter(name string, clusterScoped bool, client UserInterface, l UserLifecycle) UserHandlerFunc { adapter := &userLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *User) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *User) (*User, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*User); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 f99cd2f3..d4c58fba 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 @@ -34,7 +34,7 @@ type AuthProviderList struct { Items []AuthProvider } -type AuthProviderHandlerFunc func(key string, obj *AuthProvider) error +type AuthProviderHandlerFunc func(key string, obj *AuthProvider) (*AuthProvider, error) type AuthProviderLister interface { List(namespace string, selector labels.Selector) (ret []*AuthProvider, err error) @@ -45,8 +45,8 @@ type AuthProviderController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() AuthProviderLister - AddHandler(name string, handler AuthProviderHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler AuthProviderHandlerFunc) + AddHandler(ctx context.Context, name string, handler AuthProviderHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler AuthProviderHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type AuthProviderInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() AuthProviderController - AddHandler(name string, sync AuthProviderHandlerFunc) - AddLifecycle(name string, lifecycle AuthProviderLifecycle) - AddClusterScopedHandler(name, clusterName string, sync AuthProviderHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle AuthProviderLifecycle) + AddHandler(ctx context.Context, name string, sync AuthProviderHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle AuthProviderLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AuthProviderHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AuthProviderLifecycle) } type authProviderLister struct { @@ -115,34 +115,27 @@ func (c *authProviderController) Lister() AuthProviderLister { } } -func (c *authProviderController) AddHandler(name string, handler AuthProviderHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *authProviderController) AddHandler(ctx context.Context, name string, handler AuthProviderHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*AuthProvider); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*AuthProvider)) }) } -func (c *authProviderController) AddClusterScopedHandler(name, cluster string, handler AuthProviderHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *authProviderController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler AuthProviderHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*AuthProvider); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*AuthProvider)) }) } @@ -237,20 +230,20 @@ func (s *authProviderClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *authProviderClient) AddHandler(name string, sync AuthProviderHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *authProviderClient) AddHandler(ctx context.Context, name string, sync AuthProviderHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *authProviderClient) AddLifecycle(name string, lifecycle AuthProviderLifecycle) { +func (s *authProviderClient) AddLifecycle(ctx context.Context, name string, lifecycle AuthProviderLifecycle) { sync := NewAuthProviderLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *authProviderClient) AddClusterScopedHandler(name, clusterName string, sync AuthProviderHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *authProviderClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AuthProviderHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *authProviderClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle AuthProviderLifecycle) { +func (s *authProviderClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AuthProviderLifecycle) { sync := NewAuthProviderLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/management.cattle.io/v3public/zz_generated_auth_provider_lifecycle_adapter.go b/apis/management.cattle.io/v3public/zz_generated_auth_provider_lifecycle_adapter.go index c043bb5e..3e1fbf60 100644 --- a/apis/management.cattle.io/v3public/zz_generated_auth_provider_lifecycle_adapter.go +++ b/apis/management.cattle.io/v3public/zz_generated_auth_provider_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *authProviderLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obje func NewAuthProviderLifecycleAdapter(name string, clusterScoped bool, client AuthProviderInterface, l AuthProviderLifecycle) AuthProviderHandlerFunc { adapter := &authProviderLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *AuthProvider) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *AuthProvider) (*AuthProvider, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*AuthProvider); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 d15da437..821f799c 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 @@ -36,7 +36,7 @@ type NetworkPolicyList struct { Items []v1.NetworkPolicy } -type NetworkPolicyHandlerFunc func(key string, obj *v1.NetworkPolicy) error +type NetworkPolicyHandlerFunc func(key string, obj *v1.NetworkPolicy) (*v1.NetworkPolicy, error) type NetworkPolicyLister interface { List(namespace string, selector labels.Selector) (ret []*v1.NetworkPolicy, err error) @@ -47,8 +47,8 @@ type NetworkPolicyController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NetworkPolicyLister - AddHandler(name string, handler NetworkPolicyHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NetworkPolicyHandlerFunc) + AddHandler(ctx context.Context, name string, handler NetworkPolicyHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NetworkPolicyHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type NetworkPolicyInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NetworkPolicyController - AddHandler(name string, sync NetworkPolicyHandlerFunc) - AddLifecycle(name string, lifecycle NetworkPolicyLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NetworkPolicyHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NetworkPolicyLifecycle) + AddHandler(ctx context.Context, name string, sync NetworkPolicyHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NetworkPolicyLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NetworkPolicyHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NetworkPolicyLifecycle) } type networkPolicyLister struct { @@ -117,34 +117,27 @@ func (c *networkPolicyController) Lister() NetworkPolicyLister { } } -func (c *networkPolicyController) AddHandler(name string, handler NetworkPolicyHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *networkPolicyController) AddHandler(ctx context.Context, name string, handler NetworkPolicyHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.NetworkPolicy); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.NetworkPolicy)) }) } -func (c *networkPolicyController) AddClusterScopedHandler(name, cluster string, handler NetworkPolicyHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *networkPolicyController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NetworkPolicyHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.NetworkPolicy); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.NetworkPolicy)) }) } @@ -239,20 +232,20 @@ func (s *networkPolicyClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *networkPolicyClient) AddHandler(name string, sync NetworkPolicyHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *networkPolicyClient) AddHandler(ctx context.Context, name string, sync NetworkPolicyHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *networkPolicyClient) AddLifecycle(name string, lifecycle NetworkPolicyLifecycle) { +func (s *networkPolicyClient) AddLifecycle(ctx context.Context, name string, lifecycle NetworkPolicyLifecycle) { sync := NewNetworkPolicyLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *networkPolicyClient) AddClusterScopedHandler(name, clusterName string, sync NetworkPolicyHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *networkPolicyClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NetworkPolicyHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *networkPolicyClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NetworkPolicyLifecycle) { +func (s *networkPolicyClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NetworkPolicyLifecycle) { sync := NewNetworkPolicyLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/networking.k8s.io/v1/zz_generated_network_policy_lifecycle_adapter.go b/apis/networking.k8s.io/v1/zz_generated_network_policy_lifecycle_adapter.go index b2df6ba7..66de4ce5 100644 --- a/apis/networking.k8s.io/v1/zz_generated_network_policy_lifecycle_adapter.go +++ b/apis/networking.k8s.io/v1/zz_generated_network_policy_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *networkPolicyLifecycleAdapter) Updated(obj runtime.Object) (runtime.Obj func NewNetworkPolicyLifecycleAdapter(name string, clusterScoped bool, client NetworkPolicyInterface, l NetworkPolicyLifecycle) NetworkPolicyHandlerFunc { adapter := &networkPolicyLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.NetworkPolicy) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.NetworkPolicy) (*v1.NetworkPolicy, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.NetworkPolicy); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 6dfb716b..f5d21de2 100644 --- a/apis/project.cattle.io/v3/zz_generated_app_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_app_controller.go @@ -35,7 +35,7 @@ type AppList struct { Items []App } -type AppHandlerFunc func(key string, obj *App) error +type AppHandlerFunc func(key string, obj *App) (*App, error) type AppLister interface { List(namespace string, selector labels.Selector) (ret []*App, err error) @@ -46,8 +46,8 @@ type AppController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() AppLister - AddHandler(name string, handler AppHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler AppHandlerFunc) + AddHandler(ctx context.Context, name string, handler AppHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler AppHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type AppInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() AppController - AddHandler(name string, sync AppHandlerFunc) - AddLifecycle(name string, lifecycle AppLifecycle) - AddClusterScopedHandler(name, clusterName string, sync AppHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle AppLifecycle) + AddHandler(ctx context.Context, name string, sync AppHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle AppLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AppHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AppLifecycle) } type appLister struct { @@ -116,34 +116,27 @@ func (c *appController) Lister() AppLister { } } -func (c *appController) AddHandler(name string, handler AppHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *appController) AddHandler(ctx context.Context, name string, handler AppHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*App); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*App)) }) } -func (c *appController) AddClusterScopedHandler(name, cluster string, handler AppHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *appController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler AppHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*App); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*App)) }) } @@ -238,20 +231,20 @@ func (s *appClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *appClient) AddHandler(name string, sync AppHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *appClient) AddHandler(ctx context.Context, name string, sync AppHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *appClient) AddLifecycle(name string, lifecycle AppLifecycle) { +func (s *appClient) AddLifecycle(ctx context.Context, name string, lifecycle AppLifecycle) { sync := NewAppLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *appClient) AddClusterScopedHandler(name, clusterName string, sync AppHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *appClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AppHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *appClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle AppLifecycle) { +func (s *appClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AppLifecycle) { sync := NewAppLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_app_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_app_lifecycle_adapter.go index e341af24..ba1cd49d 100644 --- a/apis/project.cattle.io/v3/zz_generated_app_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_app_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *appLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error func NewAppLifecycleAdapter(name string, clusterScoped bool, client AppInterface, l AppLifecycle) AppHandlerFunc { adapter := &appLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *App) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *App) (*App, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*App); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 d3208544..52a32408 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 @@ -35,7 +35,7 @@ type AppRevisionList struct { Items []AppRevision } -type AppRevisionHandlerFunc func(key string, obj *AppRevision) error +type AppRevisionHandlerFunc func(key string, obj *AppRevision) (*AppRevision, error) type AppRevisionLister interface { List(namespace string, selector labels.Selector) (ret []*AppRevision, err error) @@ -46,8 +46,8 @@ type AppRevisionController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() AppRevisionLister - AddHandler(name string, handler AppRevisionHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler AppRevisionHandlerFunc) + AddHandler(ctx context.Context, name string, handler AppRevisionHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler AppRevisionHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type AppRevisionInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() AppRevisionController - AddHandler(name string, sync AppRevisionHandlerFunc) - AddLifecycle(name string, lifecycle AppRevisionLifecycle) - AddClusterScopedHandler(name, clusterName string, sync AppRevisionHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle AppRevisionLifecycle) + AddHandler(ctx context.Context, name string, sync AppRevisionHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle AppRevisionLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AppRevisionHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AppRevisionLifecycle) } type appRevisionLister struct { @@ -116,34 +116,27 @@ func (c *appRevisionController) Lister() AppRevisionLister { } } -func (c *appRevisionController) AddHandler(name string, handler AppRevisionHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *appRevisionController) AddHandler(ctx context.Context, name string, handler AppRevisionHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*AppRevision); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*AppRevision)) }) } -func (c *appRevisionController) AddClusterScopedHandler(name, cluster string, handler AppRevisionHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *appRevisionController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler AppRevisionHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*AppRevision); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*AppRevision)) }) } @@ -238,20 +231,20 @@ func (s *appRevisionClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, l return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *appRevisionClient) AddHandler(name string, sync AppRevisionHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *appRevisionClient) AddHandler(ctx context.Context, name string, sync AppRevisionHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *appRevisionClient) AddLifecycle(name string, lifecycle AppRevisionLifecycle) { +func (s *appRevisionClient) AddLifecycle(ctx context.Context, name string, lifecycle AppRevisionLifecycle) { sync := NewAppRevisionLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *appRevisionClient) AddClusterScopedHandler(name, clusterName string, sync AppRevisionHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *appRevisionClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync AppRevisionHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *appRevisionClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle AppRevisionLifecycle) { +func (s *appRevisionClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle AppRevisionLifecycle) { sync := NewAppRevisionLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_app_revision_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_app_revision_lifecycle_adapter.go index 525ba649..70d11f67 100644 --- a/apis/project.cattle.io/v3/zz_generated_app_revision_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_app_revision_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *appRevisionLifecycleAdapter) Updated(obj runtime.Object) (runtime.Objec func NewAppRevisionLifecycleAdapter(name string, clusterScoped bool, client AppRevisionInterface, l AppRevisionLifecycle) AppRevisionHandlerFunc { adapter := &appRevisionLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *AppRevision) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *AppRevision) (*AppRevision, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*AppRevision); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 b261d6d3..41b5d132 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 @@ -35,7 +35,7 @@ type BasicAuthList struct { Items []BasicAuth } -type BasicAuthHandlerFunc func(key string, obj *BasicAuth) error +type BasicAuthHandlerFunc func(key string, obj *BasicAuth) (*BasicAuth, error) type BasicAuthLister interface { List(namespace string, selector labels.Selector) (ret []*BasicAuth, err error) @@ -46,8 +46,8 @@ type BasicAuthController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() BasicAuthLister - AddHandler(name string, handler BasicAuthHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler BasicAuthHandlerFunc) + AddHandler(ctx context.Context, name string, handler BasicAuthHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler BasicAuthHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type BasicAuthInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() BasicAuthController - AddHandler(name string, sync BasicAuthHandlerFunc) - AddLifecycle(name string, lifecycle BasicAuthLifecycle) - AddClusterScopedHandler(name, clusterName string, sync BasicAuthHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle BasicAuthLifecycle) + AddHandler(ctx context.Context, name string, sync BasicAuthHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle BasicAuthLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync BasicAuthHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle BasicAuthLifecycle) } type basicAuthLister struct { @@ -116,34 +116,27 @@ func (c *basicAuthController) Lister() BasicAuthLister { } } -func (c *basicAuthController) AddHandler(name string, handler BasicAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *basicAuthController) AddHandler(ctx context.Context, name string, handler BasicAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*BasicAuth); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*BasicAuth)) }) } -func (c *basicAuthController) AddClusterScopedHandler(name, cluster string, handler BasicAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *basicAuthController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler BasicAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*BasicAuth); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*BasicAuth)) }) } @@ -238,20 +231,20 @@ func (s *basicAuthClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, lis return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *basicAuthClient) AddHandler(name string, sync BasicAuthHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *basicAuthClient) AddHandler(ctx context.Context, name string, sync BasicAuthHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *basicAuthClient) AddLifecycle(name string, lifecycle BasicAuthLifecycle) { +func (s *basicAuthClient) AddLifecycle(ctx context.Context, name string, lifecycle BasicAuthLifecycle) { sync := NewBasicAuthLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *basicAuthClient) AddClusterScopedHandler(name, clusterName string, sync BasicAuthHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *basicAuthClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync BasicAuthHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *basicAuthClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle BasicAuthLifecycle) { +func (s *basicAuthClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle BasicAuthLifecycle) { sync := NewBasicAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_basic_auth_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_basic_auth_lifecycle_adapter.go index edc6874d..8acc5c7e 100644 --- a/apis/project.cattle.io/v3/zz_generated_basic_auth_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_basic_auth_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *basicAuthLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewBasicAuthLifecycleAdapter(name string, clusterScoped bool, client BasicAuthInterface, l BasicAuthLifecycle) BasicAuthHandlerFunc { adapter := &basicAuthLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *BasicAuth) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *BasicAuth) (*BasicAuth, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*BasicAuth); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 f0db988b..18845aa9 100644 --- a/apis/project.cattle.io/v3/zz_generated_certificate_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_certificate_controller.go @@ -35,7 +35,7 @@ type CertificateList struct { Items []Certificate } -type CertificateHandlerFunc func(key string, obj *Certificate) error +type CertificateHandlerFunc func(key string, obj *Certificate) (*Certificate, error) type CertificateLister interface { List(namespace string, selector labels.Selector) (ret []*Certificate, err error) @@ -46,8 +46,8 @@ type CertificateController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() CertificateLister - AddHandler(name string, handler CertificateHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler CertificateHandlerFunc) + AddHandler(ctx context.Context, name string, handler CertificateHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler CertificateHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type CertificateInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() CertificateController - AddHandler(name string, sync CertificateHandlerFunc) - AddLifecycle(name string, lifecycle CertificateLifecycle) - AddClusterScopedHandler(name, clusterName string, sync CertificateHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle CertificateLifecycle) + AddHandler(ctx context.Context, name string, sync CertificateHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle CertificateLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CertificateHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CertificateLifecycle) } type certificateLister struct { @@ -116,34 +116,27 @@ func (c *certificateController) Lister() CertificateLister { } } -func (c *certificateController) AddHandler(name string, handler CertificateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *certificateController) AddHandler(ctx context.Context, name string, handler CertificateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Certificate); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Certificate)) }) } -func (c *certificateController) AddClusterScopedHandler(name, cluster string, handler CertificateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *certificateController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler CertificateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Certificate); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Certificate)) }) } @@ -238,20 +231,20 @@ func (s *certificateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, l return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *certificateClient) AddHandler(name string, sync CertificateHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *certificateClient) AddHandler(ctx context.Context, name string, sync CertificateHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *certificateClient) AddLifecycle(name string, lifecycle CertificateLifecycle) { +func (s *certificateClient) AddLifecycle(ctx context.Context, name string, lifecycle CertificateLifecycle) { sync := NewCertificateLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *certificateClient) AddClusterScopedHandler(name, clusterName string, sync CertificateHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *certificateClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync CertificateHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *certificateClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle CertificateLifecycle) { +func (s *certificateClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle CertificateLifecycle) { sync := NewCertificateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_certificate_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_certificate_lifecycle_adapter.go index e8333d83..d21ed287 100644 --- a/apis/project.cattle.io/v3/zz_generated_certificate_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_certificate_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *certificateLifecycleAdapter) Updated(obj runtime.Object) (runtime.Objec func NewCertificateLifecycleAdapter(name string, clusterScoped bool, client CertificateInterface, l CertificateLifecycle) CertificateHandlerFunc { adapter := &certificateLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Certificate) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Certificate) (*Certificate, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Certificate); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 6587c6a3..6406d1d0 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 @@ -35,7 +35,7 @@ type DockerCredentialList struct { Items []DockerCredential } -type DockerCredentialHandlerFunc func(key string, obj *DockerCredential) error +type DockerCredentialHandlerFunc func(key string, obj *DockerCredential) (*DockerCredential, error) type DockerCredentialLister interface { List(namespace string, selector labels.Selector) (ret []*DockerCredential, err error) @@ -46,8 +46,8 @@ type DockerCredentialController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() DockerCredentialLister - AddHandler(name string, handler DockerCredentialHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler DockerCredentialHandlerFunc) + AddHandler(ctx context.Context, name string, handler DockerCredentialHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler DockerCredentialHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type DockerCredentialInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() DockerCredentialController - AddHandler(name string, sync DockerCredentialHandlerFunc) - AddLifecycle(name string, lifecycle DockerCredentialLifecycle) - AddClusterScopedHandler(name, clusterName string, sync DockerCredentialHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle DockerCredentialLifecycle) + AddHandler(ctx context.Context, name string, sync DockerCredentialHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle DockerCredentialLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DockerCredentialHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DockerCredentialLifecycle) } type dockerCredentialLister struct { @@ -116,34 +116,27 @@ func (c *dockerCredentialController) Lister() DockerCredentialLister { } } -func (c *dockerCredentialController) AddHandler(name string, handler DockerCredentialHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *dockerCredentialController) AddHandler(ctx context.Context, name string, handler DockerCredentialHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*DockerCredential); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*DockerCredential)) }) } -func (c *dockerCredentialController) AddClusterScopedHandler(name, cluster string, handler DockerCredentialHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *dockerCredentialController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler DockerCredentialHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*DockerCredential); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*DockerCredential)) }) } @@ -238,20 +231,20 @@ func (s *dockerCredentialClient) DeleteCollection(deleteOpts *metav1.DeleteOptio return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *dockerCredentialClient) AddHandler(name string, sync DockerCredentialHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *dockerCredentialClient) AddHandler(ctx context.Context, name string, sync DockerCredentialHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *dockerCredentialClient) AddLifecycle(name string, lifecycle DockerCredentialLifecycle) { +func (s *dockerCredentialClient) AddLifecycle(ctx context.Context, name string, lifecycle DockerCredentialLifecycle) { sync := NewDockerCredentialLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *dockerCredentialClient) AddClusterScopedHandler(name, clusterName string, sync DockerCredentialHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *dockerCredentialClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DockerCredentialHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *dockerCredentialClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle DockerCredentialLifecycle) { +func (s *dockerCredentialClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DockerCredentialLifecycle) { sync := NewDockerCredentialLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_docker_credential_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_docker_credential_lifecycle_adapter.go index 243c7935..e1ceddc2 100644 --- a/apis/project.cattle.io/v3/zz_generated_docker_credential_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_docker_credential_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *dockerCredentialLifecycleAdapter) Updated(obj runtime.Object) (runtime. func NewDockerCredentialLifecycleAdapter(name string, clusterScoped bool, client DockerCredentialInterface, l DockerCredentialLifecycle) DockerCredentialHandlerFunc { adapter := &dockerCredentialLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *DockerCredential) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *DockerCredential) (*DockerCredential, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*DockerCredential); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 071fd194..4a61e778 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 @@ -35,7 +35,7 @@ type NamespacedBasicAuthList struct { Items []NamespacedBasicAuth } -type NamespacedBasicAuthHandlerFunc func(key string, obj *NamespacedBasicAuth) error +type NamespacedBasicAuthHandlerFunc func(key string, obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error) type NamespacedBasicAuthLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedBasicAuth, err error) @@ -46,8 +46,8 @@ type NamespacedBasicAuthController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NamespacedBasicAuthLister - AddHandler(name string, handler NamespacedBasicAuthHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespacedBasicAuthHandlerFunc) + AddHandler(ctx context.Context, name string, handler NamespacedBasicAuthHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NamespacedBasicAuthHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NamespacedBasicAuthInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NamespacedBasicAuthController - AddHandler(name string, sync NamespacedBasicAuthHandlerFunc) - AddLifecycle(name string, lifecycle NamespacedBasicAuthLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespacedBasicAuthHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedBasicAuthLifecycle) + AddHandler(ctx context.Context, name string, sync NamespacedBasicAuthHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NamespacedBasicAuthLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedBasicAuthHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedBasicAuthLifecycle) } type namespacedBasicAuthLister struct { @@ -116,34 +116,27 @@ func (c *namespacedBasicAuthController) Lister() NamespacedBasicAuthLister { } } -func (c *namespacedBasicAuthController) AddHandler(name string, handler NamespacedBasicAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedBasicAuthController) AddHandler(ctx context.Context, name string, handler NamespacedBasicAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedBasicAuth); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NamespacedBasicAuth)) }) } -func (c *namespacedBasicAuthController) AddClusterScopedHandler(name, cluster string, handler NamespacedBasicAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedBasicAuthController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NamespacedBasicAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedBasicAuth); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NamespacedBasicAuth)) }) } @@ -238,20 +231,20 @@ func (s *namespacedBasicAuthClient) DeleteCollection(deleteOpts *metav1.DeleteOp return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *namespacedBasicAuthClient) AddHandler(name string, sync NamespacedBasicAuthHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *namespacedBasicAuthClient) AddHandler(ctx context.Context, name string, sync NamespacedBasicAuthHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedBasicAuthClient) AddLifecycle(name string, lifecycle NamespacedBasicAuthLifecycle) { +func (s *namespacedBasicAuthClient) AddLifecycle(ctx context.Context, name string, lifecycle NamespacedBasicAuthLifecycle) { sync := NewNamespacedBasicAuthLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedBasicAuthClient) AddClusterScopedHandler(name, clusterName string, sync NamespacedBasicAuthHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *namespacedBasicAuthClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedBasicAuthHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *namespacedBasicAuthClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedBasicAuthLifecycle) { +func (s *namespacedBasicAuthClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedBasicAuthLifecycle) { sync := NewNamespacedBasicAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_lifecycle_adapter.go index 1dff293b..461675d7 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_basic_auth_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *namespacedBasicAuthLifecycleAdapter) Updated(obj runtime.Object) (runti func NewNamespacedBasicAuthLifecycleAdapter(name string, clusterScoped bool, client NamespacedBasicAuthInterface, l NamespacedBasicAuthLifecycle) NamespacedBasicAuthHandlerFunc { adapter := &namespacedBasicAuthLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NamespacedBasicAuth) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NamespacedBasicAuth) (*NamespacedBasicAuth, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NamespacedBasicAuth); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 f61995d0..0882f35f 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 @@ -35,7 +35,7 @@ type NamespacedCertificateList struct { Items []NamespacedCertificate } -type NamespacedCertificateHandlerFunc func(key string, obj *NamespacedCertificate) error +type NamespacedCertificateHandlerFunc func(key string, obj *NamespacedCertificate) (*NamespacedCertificate, error) type NamespacedCertificateLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedCertificate, err error) @@ -46,8 +46,8 @@ type NamespacedCertificateController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NamespacedCertificateLister - AddHandler(name string, handler NamespacedCertificateHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespacedCertificateHandlerFunc) + AddHandler(ctx context.Context, name string, handler NamespacedCertificateHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NamespacedCertificateHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NamespacedCertificateInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NamespacedCertificateController - AddHandler(name string, sync NamespacedCertificateHandlerFunc) - AddLifecycle(name string, lifecycle NamespacedCertificateLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespacedCertificateHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedCertificateLifecycle) + AddHandler(ctx context.Context, name string, sync NamespacedCertificateHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NamespacedCertificateLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedCertificateHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedCertificateLifecycle) } type namespacedCertificateLister struct { @@ -116,34 +116,27 @@ func (c *namespacedCertificateController) Lister() NamespacedCertificateLister { } } -func (c *namespacedCertificateController) AddHandler(name string, handler NamespacedCertificateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedCertificateController) AddHandler(ctx context.Context, name string, handler NamespacedCertificateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedCertificate); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NamespacedCertificate)) }) } -func (c *namespacedCertificateController) AddClusterScopedHandler(name, cluster string, handler NamespacedCertificateHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedCertificateController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NamespacedCertificateHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedCertificate); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NamespacedCertificate)) }) } @@ -238,20 +231,20 @@ func (s *namespacedCertificateClient) DeleteCollection(deleteOpts *metav1.Delete return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *namespacedCertificateClient) AddHandler(name string, sync NamespacedCertificateHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *namespacedCertificateClient) AddHandler(ctx context.Context, name string, sync NamespacedCertificateHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedCertificateClient) AddLifecycle(name string, lifecycle NamespacedCertificateLifecycle) { +func (s *namespacedCertificateClient) AddLifecycle(ctx context.Context, name string, lifecycle NamespacedCertificateLifecycle) { sync := NewNamespacedCertificateLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedCertificateClient) AddClusterScopedHandler(name, clusterName string, sync NamespacedCertificateHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *namespacedCertificateClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedCertificateHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *namespacedCertificateClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedCertificateLifecycle) { +func (s *namespacedCertificateClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedCertificateLifecycle) { sync := NewNamespacedCertificateLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_lifecycle_adapter.go index b018ee3d..c4a4d33e 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_certificate_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *namespacedCertificateLifecycleAdapter) Updated(obj runtime.Object) (run func NewNamespacedCertificateLifecycleAdapter(name string, clusterScoped bool, client NamespacedCertificateInterface, l NamespacedCertificateLifecycle) NamespacedCertificateHandlerFunc { adapter := &namespacedCertificateLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NamespacedCertificate) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NamespacedCertificate) (*NamespacedCertificate, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NamespacedCertificate); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 99e1984f..d7454e9f 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 @@ -35,7 +35,7 @@ type NamespacedDockerCredentialList struct { Items []NamespacedDockerCredential } -type NamespacedDockerCredentialHandlerFunc func(key string, obj *NamespacedDockerCredential) error +type NamespacedDockerCredentialHandlerFunc func(key string, obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error) type NamespacedDockerCredentialLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedDockerCredential, err error) @@ -46,8 +46,8 @@ type NamespacedDockerCredentialController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NamespacedDockerCredentialLister - AddHandler(name string, handler NamespacedDockerCredentialHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespacedDockerCredentialHandlerFunc) + AddHandler(ctx context.Context, name string, handler NamespacedDockerCredentialHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NamespacedDockerCredentialHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NamespacedDockerCredentialInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NamespacedDockerCredentialController - AddHandler(name string, sync NamespacedDockerCredentialHandlerFunc) - AddLifecycle(name string, lifecycle NamespacedDockerCredentialLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespacedDockerCredentialHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedDockerCredentialLifecycle) + AddHandler(ctx context.Context, name string, sync NamespacedDockerCredentialHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NamespacedDockerCredentialLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedDockerCredentialHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedDockerCredentialLifecycle) } type namespacedDockerCredentialLister struct { @@ -116,34 +116,27 @@ func (c *namespacedDockerCredentialController) Lister() NamespacedDockerCredenti } } -func (c *namespacedDockerCredentialController) AddHandler(name string, handler NamespacedDockerCredentialHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedDockerCredentialController) AddHandler(ctx context.Context, name string, handler NamespacedDockerCredentialHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedDockerCredential); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NamespacedDockerCredential)) }) } -func (c *namespacedDockerCredentialController) AddClusterScopedHandler(name, cluster string, handler NamespacedDockerCredentialHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedDockerCredentialController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NamespacedDockerCredentialHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedDockerCredential); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NamespacedDockerCredential)) }) } @@ -238,20 +231,20 @@ func (s *namespacedDockerCredentialClient) DeleteCollection(deleteOpts *metav1.D return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *namespacedDockerCredentialClient) AddHandler(name string, sync NamespacedDockerCredentialHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *namespacedDockerCredentialClient) AddHandler(ctx context.Context, name string, sync NamespacedDockerCredentialHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedDockerCredentialClient) AddLifecycle(name string, lifecycle NamespacedDockerCredentialLifecycle) { +func (s *namespacedDockerCredentialClient) AddLifecycle(ctx context.Context, name string, lifecycle NamespacedDockerCredentialLifecycle) { sync := NewNamespacedDockerCredentialLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedDockerCredentialClient) AddClusterScopedHandler(name, clusterName string, sync NamespacedDockerCredentialHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *namespacedDockerCredentialClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedDockerCredentialHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *namespacedDockerCredentialClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedDockerCredentialLifecycle) { +func (s *namespacedDockerCredentialClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedDockerCredentialLifecycle) { sync := NewNamespacedDockerCredentialLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_lifecycle_adapter.go index 1a0cd719..33d70b37 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_docker_credential_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *namespacedDockerCredentialLifecycleAdapter) Updated(obj runtime.Object) func NewNamespacedDockerCredentialLifecycleAdapter(name string, clusterScoped bool, client NamespacedDockerCredentialInterface, l NamespacedDockerCredentialLifecycle) NamespacedDockerCredentialHandlerFunc { adapter := &namespacedDockerCredentialLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NamespacedDockerCredential) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NamespacedDockerCredential) (*NamespacedDockerCredential, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NamespacedDockerCredential); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 7f53a756..8d95a6f2 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 @@ -35,7 +35,7 @@ type NamespacedServiceAccountTokenList struct { Items []NamespacedServiceAccountToken } -type NamespacedServiceAccountTokenHandlerFunc func(key string, obj *NamespacedServiceAccountToken) error +type NamespacedServiceAccountTokenHandlerFunc func(key string, obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) type NamespacedServiceAccountTokenLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedServiceAccountToken, err error) @@ -46,8 +46,8 @@ type NamespacedServiceAccountTokenController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NamespacedServiceAccountTokenLister - AddHandler(name string, handler NamespacedServiceAccountTokenHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespacedServiceAccountTokenHandlerFunc) + AddHandler(ctx context.Context, name string, handler NamespacedServiceAccountTokenHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NamespacedServiceAccountTokenHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NamespacedServiceAccountTokenInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NamespacedServiceAccountTokenController - AddHandler(name string, sync NamespacedServiceAccountTokenHandlerFunc) - AddLifecycle(name string, lifecycle NamespacedServiceAccountTokenLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespacedServiceAccountTokenHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedServiceAccountTokenLifecycle) + AddHandler(ctx context.Context, name string, sync NamespacedServiceAccountTokenHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NamespacedServiceAccountTokenLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedServiceAccountTokenHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedServiceAccountTokenLifecycle) } type namespacedServiceAccountTokenLister struct { @@ -116,34 +116,27 @@ func (c *namespacedServiceAccountTokenController) Lister() NamespacedServiceAcco } } -func (c *namespacedServiceAccountTokenController) AddHandler(name string, handler NamespacedServiceAccountTokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedServiceAccountTokenController) AddHandler(ctx context.Context, name string, handler NamespacedServiceAccountTokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedServiceAccountToken); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NamespacedServiceAccountToken)) }) } -func (c *namespacedServiceAccountTokenController) AddClusterScopedHandler(name, cluster string, handler NamespacedServiceAccountTokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedServiceAccountTokenController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NamespacedServiceAccountTokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedServiceAccountToken); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NamespacedServiceAccountToken)) }) } @@ -238,20 +231,20 @@ func (s *namespacedServiceAccountTokenClient) DeleteCollection(deleteOpts *metav return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *namespacedServiceAccountTokenClient) AddHandler(name string, sync NamespacedServiceAccountTokenHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *namespacedServiceAccountTokenClient) AddHandler(ctx context.Context, name string, sync NamespacedServiceAccountTokenHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedServiceAccountTokenClient) AddLifecycle(name string, lifecycle NamespacedServiceAccountTokenLifecycle) { +func (s *namespacedServiceAccountTokenClient) AddLifecycle(ctx context.Context, name string, lifecycle NamespacedServiceAccountTokenLifecycle) { sync := NewNamespacedServiceAccountTokenLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedServiceAccountTokenClient) AddClusterScopedHandler(name, clusterName string, sync NamespacedServiceAccountTokenHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *namespacedServiceAccountTokenClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedServiceAccountTokenHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *namespacedServiceAccountTokenClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedServiceAccountTokenLifecycle) { +func (s *namespacedServiceAccountTokenClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedServiceAccountTokenLifecycle) { sync := NewNamespacedServiceAccountTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_lifecycle_adapter.go index 959be1eb..8868cbb8 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_service_account_token_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *namespacedServiceAccountTokenLifecycleAdapter) Updated(obj runtime.Obje func NewNamespacedServiceAccountTokenLifecycleAdapter(name string, clusterScoped bool, client NamespacedServiceAccountTokenInterface, l NamespacedServiceAccountTokenLifecycle) NamespacedServiceAccountTokenHandlerFunc { adapter := &namespacedServiceAccountTokenLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NamespacedServiceAccountToken) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NamespacedServiceAccountToken) (*NamespacedServiceAccountToken, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NamespacedServiceAccountToken); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 af86aad6..2c0f16d7 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 @@ -35,7 +35,7 @@ type NamespacedSSHAuthList struct { Items []NamespacedSSHAuth } -type NamespacedSSHAuthHandlerFunc func(key string, obj *NamespacedSSHAuth) error +type NamespacedSSHAuthHandlerFunc func(key string, obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error) type NamespacedSSHAuthLister interface { List(namespace string, selector labels.Selector) (ret []*NamespacedSSHAuth, err error) @@ -46,8 +46,8 @@ type NamespacedSSHAuthController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() NamespacedSSHAuthLister - AddHandler(name string, handler NamespacedSSHAuthHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespacedSSHAuthHandlerFunc) + AddHandler(ctx context.Context, name string, handler NamespacedSSHAuthHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NamespacedSSHAuthHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type NamespacedSSHAuthInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() NamespacedSSHAuthController - AddHandler(name string, sync NamespacedSSHAuthHandlerFunc) - AddLifecycle(name string, lifecycle NamespacedSSHAuthLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespacedSSHAuthHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedSSHAuthLifecycle) + AddHandler(ctx context.Context, name string, sync NamespacedSSHAuthHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle NamespacedSSHAuthLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedSSHAuthHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedSSHAuthLifecycle) } type namespacedSshAuthLister struct { @@ -116,34 +116,27 @@ func (c *namespacedSshAuthController) Lister() NamespacedSSHAuthLister { } } -func (c *namespacedSshAuthController) AddHandler(name string, handler NamespacedSSHAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedSshAuthController) AddHandler(ctx context.Context, name string, handler NamespacedSSHAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedSSHAuth); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*NamespacedSSHAuth)) }) } -func (c *namespacedSshAuthController) AddClusterScopedHandler(name, cluster string, handler NamespacedSSHAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *namespacedSshAuthController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NamespacedSSHAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*NamespacedSSHAuth); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*NamespacedSSHAuth)) }) } @@ -238,20 +231,20 @@ func (s *namespacedSshAuthClient) DeleteCollection(deleteOpts *metav1.DeleteOpti return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *namespacedSshAuthClient) AddHandler(name string, sync NamespacedSSHAuthHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *namespacedSshAuthClient) AddHandler(ctx context.Context, name string, sync NamespacedSSHAuthHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedSshAuthClient) AddLifecycle(name string, lifecycle NamespacedSSHAuthLifecycle) { +func (s *namespacedSshAuthClient) AddLifecycle(ctx context.Context, name string, lifecycle NamespacedSSHAuthLifecycle) { sync := NewNamespacedSSHAuthLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *namespacedSshAuthClient) AddClusterScopedHandler(name, clusterName string, sync NamespacedSSHAuthHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *namespacedSshAuthClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NamespacedSSHAuthHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *namespacedSshAuthClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespacedSSHAuthLifecycle) { +func (s *namespacedSshAuthClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NamespacedSSHAuthLifecycle) { sync := NewNamespacedSSHAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_lifecycle_adapter.go index d482f32d..c3039778 100644 --- a/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_namespaced_ssh_auth_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *namespacedSshAuthLifecycleAdapter) Updated(obj runtime.Object) (runtime func NewNamespacedSSHAuthLifecycleAdapter(name string, clusterScoped bool, client NamespacedSSHAuthInterface, l NamespacedSSHAuthLifecycle) NamespacedSSHAuthHandlerFunc { adapter := &namespacedSshAuthLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NamespacedSSHAuth) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *NamespacedSSHAuth) (*NamespacedSSHAuth, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*NamespacedSSHAuth); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 6266bcf7..b3905120 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_controller.go @@ -35,7 +35,7 @@ type PipelineList struct { Items []Pipeline } -type PipelineHandlerFunc func(key string, obj *Pipeline) error +type PipelineHandlerFunc func(key string, obj *Pipeline) (*Pipeline, error) type PipelineLister interface { List(namespace string, selector labels.Selector) (ret []*Pipeline, err error) @@ -46,8 +46,8 @@ type PipelineController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PipelineLister - AddHandler(name string, handler PipelineHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PipelineHandlerFunc) + AddHandler(ctx context.Context, name string, handler PipelineHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PipelineHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type PipelineInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PipelineController - AddHandler(name string, sync PipelineHandlerFunc) - AddLifecycle(name string, lifecycle PipelineLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PipelineHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PipelineLifecycle) + AddHandler(ctx context.Context, name string, sync PipelineHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PipelineLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PipelineHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PipelineLifecycle) } type pipelineLister struct { @@ -116,34 +116,27 @@ func (c *pipelineController) Lister() PipelineLister { } } -func (c *pipelineController) AddHandler(name string, handler PipelineHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *pipelineController) AddHandler(ctx context.Context, name string, handler PipelineHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Pipeline); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Pipeline)) }) } -func (c *pipelineController) AddClusterScopedHandler(name, cluster string, handler PipelineHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *pipelineController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PipelineHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Pipeline); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Pipeline)) }) } @@ -238,20 +231,20 @@ func (s *pipelineClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, list return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *pipelineClient) AddHandler(name string, sync PipelineHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *pipelineClient) AddHandler(ctx context.Context, name string, sync PipelineHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *pipelineClient) AddLifecycle(name string, lifecycle PipelineLifecycle) { +func (s *pipelineClient) AddLifecycle(ctx context.Context, name string, lifecycle PipelineLifecycle) { sync := NewPipelineLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *pipelineClient) AddClusterScopedHandler(name, clusterName string, sync PipelineHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *pipelineClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PipelineHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *pipelineClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PipelineLifecycle) { +func (s *pipelineClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PipelineLifecycle) { sync := NewPipelineLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } 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 83d3e357..3e82b1dd 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 @@ -35,7 +35,7 @@ type PipelineExecutionList struct { Items []PipelineExecution } -type PipelineExecutionHandlerFunc func(key string, obj *PipelineExecution) error +type PipelineExecutionHandlerFunc func(key string, obj *PipelineExecution) (*PipelineExecution, error) type PipelineExecutionLister interface { List(namespace string, selector labels.Selector) (ret []*PipelineExecution, err error) @@ -46,8 +46,8 @@ type PipelineExecutionController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PipelineExecutionLister - AddHandler(name string, handler PipelineExecutionHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PipelineExecutionHandlerFunc) + AddHandler(ctx context.Context, name string, handler PipelineExecutionHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PipelineExecutionHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type PipelineExecutionInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PipelineExecutionController - AddHandler(name string, sync PipelineExecutionHandlerFunc) - AddLifecycle(name string, lifecycle PipelineExecutionLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PipelineExecutionHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PipelineExecutionLifecycle) + AddHandler(ctx context.Context, name string, sync PipelineExecutionHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PipelineExecutionLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PipelineExecutionHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PipelineExecutionLifecycle) } type pipelineExecutionLister struct { @@ -116,34 +116,27 @@ func (c *pipelineExecutionController) Lister() PipelineExecutionLister { } } -func (c *pipelineExecutionController) AddHandler(name string, handler PipelineExecutionHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *pipelineExecutionController) AddHandler(ctx context.Context, name string, handler PipelineExecutionHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PipelineExecution); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*PipelineExecution)) }) } -func (c *pipelineExecutionController) AddClusterScopedHandler(name, cluster string, handler PipelineExecutionHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *pipelineExecutionController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PipelineExecutionHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PipelineExecution); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*PipelineExecution)) }) } @@ -238,20 +231,20 @@ func (s *pipelineExecutionClient) DeleteCollection(deleteOpts *metav1.DeleteOpti return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *pipelineExecutionClient) AddHandler(name string, sync PipelineExecutionHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *pipelineExecutionClient) AddHandler(ctx context.Context, name string, sync PipelineExecutionHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *pipelineExecutionClient) AddLifecycle(name string, lifecycle PipelineExecutionLifecycle) { +func (s *pipelineExecutionClient) AddLifecycle(ctx context.Context, name string, lifecycle PipelineExecutionLifecycle) { sync := NewPipelineExecutionLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *pipelineExecutionClient) AddClusterScopedHandler(name, clusterName string, sync PipelineExecutionHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *pipelineExecutionClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PipelineExecutionHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *pipelineExecutionClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PipelineExecutionLifecycle) { +func (s *pipelineExecutionClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PipelineExecutionLifecycle) { sync := NewPipelineExecutionLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_pipeline_execution_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_pipeline_execution_lifecycle_adapter.go index 29ae1b8c..bc9817f7 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_execution_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_execution_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *pipelineExecutionLifecycleAdapter) Updated(obj runtime.Object) (runtime func NewPipelineExecutionLifecycleAdapter(name string, clusterScoped bool, client PipelineExecutionInterface, l PipelineExecutionLifecycle) PipelineExecutionHandlerFunc { adapter := &pipelineExecutionLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *PipelineExecution) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *PipelineExecution) (*PipelineExecution, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*PipelineExecution); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } diff --git a/apis/project.cattle.io/v3/zz_generated_pipeline_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_pipeline_lifecycle_adapter.go index e14eab49..9ab89de7 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *pipelineLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewPipelineLifecycleAdapter(name string, clusterScoped bool, client PipelineInterface, l PipelineLifecycle) PipelineHandlerFunc { adapter := &pipelineLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Pipeline) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Pipeline) (*Pipeline, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Pipeline); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 199640e1..e1fa7147 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 @@ -35,7 +35,7 @@ type PipelineSettingList struct { Items []PipelineSetting } -type PipelineSettingHandlerFunc func(key string, obj *PipelineSetting) error +type PipelineSettingHandlerFunc func(key string, obj *PipelineSetting) (*PipelineSetting, error) type PipelineSettingLister interface { List(namespace string, selector labels.Selector) (ret []*PipelineSetting, err error) @@ -46,8 +46,8 @@ type PipelineSettingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() PipelineSettingLister - AddHandler(name string, handler PipelineSettingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler PipelineSettingHandlerFunc) + AddHandler(ctx context.Context, name string, handler PipelineSettingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler PipelineSettingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type PipelineSettingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() PipelineSettingController - AddHandler(name string, sync PipelineSettingHandlerFunc) - AddLifecycle(name string, lifecycle PipelineSettingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync PipelineSettingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle PipelineSettingLifecycle) + AddHandler(ctx context.Context, name string, sync PipelineSettingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle PipelineSettingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PipelineSettingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PipelineSettingLifecycle) } type pipelineSettingLister struct { @@ -116,34 +116,27 @@ func (c *pipelineSettingController) Lister() PipelineSettingLister { } } -func (c *pipelineSettingController) AddHandler(name string, handler PipelineSettingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *pipelineSettingController) AddHandler(ctx context.Context, name string, handler PipelineSettingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PipelineSetting); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*PipelineSetting)) }) } -func (c *pipelineSettingController) AddClusterScopedHandler(name, cluster string, handler PipelineSettingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *pipelineSettingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler PipelineSettingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*PipelineSetting); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*PipelineSetting)) }) } @@ -238,20 +231,20 @@ func (s *pipelineSettingClient) DeleteCollection(deleteOpts *metav1.DeleteOption return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *pipelineSettingClient) AddHandler(name string, sync PipelineSettingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *pipelineSettingClient) AddHandler(ctx context.Context, name string, sync PipelineSettingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *pipelineSettingClient) AddLifecycle(name string, lifecycle PipelineSettingLifecycle) { +func (s *pipelineSettingClient) AddLifecycle(ctx context.Context, name string, lifecycle PipelineSettingLifecycle) { sync := NewPipelineSettingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *pipelineSettingClient) AddClusterScopedHandler(name, clusterName string, sync PipelineSettingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *pipelineSettingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync PipelineSettingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *pipelineSettingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle PipelineSettingLifecycle) { +func (s *pipelineSettingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle PipelineSettingLifecycle) { sync := NewPipelineSettingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_pipeline_setting_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_pipeline_setting_lifecycle_adapter.go index 6ba71da5..04a42772 100644 --- a/apis/project.cattle.io/v3/zz_generated_pipeline_setting_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_pipeline_setting_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *pipelineSettingLifecycleAdapter) Updated(obj runtime.Object) (runtime.O func NewPipelineSettingLifecycleAdapter(name string, clusterScoped bool, client PipelineSettingInterface, l PipelineSettingLifecycle) PipelineSettingHandlerFunc { adapter := &pipelineSettingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *PipelineSetting) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *PipelineSetting) (*PipelineSetting, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*PipelineSetting); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 7896535e..286b9c08 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 @@ -35,7 +35,7 @@ type ServiceAccountTokenList struct { Items []ServiceAccountToken } -type ServiceAccountTokenHandlerFunc func(key string, obj *ServiceAccountToken) error +type ServiceAccountTokenHandlerFunc func(key string, obj *ServiceAccountToken) (*ServiceAccountToken, error) type ServiceAccountTokenLister interface { List(namespace string, selector labels.Selector) (ret []*ServiceAccountToken, err error) @@ -46,8 +46,8 @@ type ServiceAccountTokenController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ServiceAccountTokenLister - AddHandler(name string, handler ServiceAccountTokenHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ServiceAccountTokenHandlerFunc) + AddHandler(ctx context.Context, name string, handler ServiceAccountTokenHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ServiceAccountTokenHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ServiceAccountTokenInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ServiceAccountTokenController - AddHandler(name string, sync ServiceAccountTokenHandlerFunc) - AddLifecycle(name string, lifecycle ServiceAccountTokenLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ServiceAccountTokenHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ServiceAccountTokenLifecycle) + AddHandler(ctx context.Context, name string, sync ServiceAccountTokenHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ServiceAccountTokenLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceAccountTokenHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceAccountTokenLifecycle) } type serviceAccountTokenLister struct { @@ -116,34 +116,27 @@ func (c *serviceAccountTokenController) Lister() ServiceAccountTokenLister { } } -func (c *serviceAccountTokenController) AddHandler(name string, handler ServiceAccountTokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *serviceAccountTokenController) AddHandler(ctx context.Context, name string, handler ServiceAccountTokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ServiceAccountToken); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*ServiceAccountToken)) }) } -func (c *serviceAccountTokenController) AddClusterScopedHandler(name, cluster string, handler ServiceAccountTokenHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *serviceAccountTokenController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ServiceAccountTokenHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*ServiceAccountToken); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*ServiceAccountToken)) }) } @@ -238,20 +231,20 @@ func (s *serviceAccountTokenClient) DeleteCollection(deleteOpts *metav1.DeleteOp return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *serviceAccountTokenClient) AddHandler(name string, sync ServiceAccountTokenHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *serviceAccountTokenClient) AddHandler(ctx context.Context, name string, sync ServiceAccountTokenHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *serviceAccountTokenClient) AddLifecycle(name string, lifecycle ServiceAccountTokenLifecycle) { +func (s *serviceAccountTokenClient) AddLifecycle(ctx context.Context, name string, lifecycle ServiceAccountTokenLifecycle) { sync := NewServiceAccountTokenLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *serviceAccountTokenClient) AddClusterScopedHandler(name, clusterName string, sync ServiceAccountTokenHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *serviceAccountTokenClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ServiceAccountTokenHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *serviceAccountTokenClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ServiceAccountTokenLifecycle) { +func (s *serviceAccountTokenClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ServiceAccountTokenLifecycle) { sync := NewServiceAccountTokenLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_service_account_token_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_service_account_token_lifecycle_adapter.go index 7e4c56b5..5b84e5f8 100644 --- a/apis/project.cattle.io/v3/zz_generated_service_account_token_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_service_account_token_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *serviceAccountTokenLifecycleAdapter) Updated(obj runtime.Object) (runti func NewServiceAccountTokenLifecycleAdapter(name string, clusterScoped bool, client ServiceAccountTokenInterface, l ServiceAccountTokenLifecycle) ServiceAccountTokenHandlerFunc { adapter := &serviceAccountTokenLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ServiceAccountToken) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *ServiceAccountToken) (*ServiceAccountToken, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*ServiceAccountToken); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 c1f5e9a1..b97faf3c 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 @@ -35,7 +35,7 @@ type SourceCodeCredentialList struct { Items []SourceCodeCredential } -type SourceCodeCredentialHandlerFunc func(key string, obj *SourceCodeCredential) error +type SourceCodeCredentialHandlerFunc func(key string, obj *SourceCodeCredential) (*SourceCodeCredential, error) type SourceCodeCredentialLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeCredential, err error) @@ -46,8 +46,8 @@ type SourceCodeCredentialController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SourceCodeCredentialLister - AddHandler(name string, handler SourceCodeCredentialHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SourceCodeCredentialHandlerFunc) + AddHandler(ctx context.Context, name string, handler SourceCodeCredentialHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SourceCodeCredentialHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type SourceCodeCredentialInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SourceCodeCredentialController - AddHandler(name string, sync SourceCodeCredentialHandlerFunc) - AddLifecycle(name string, lifecycle SourceCodeCredentialLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SourceCodeCredentialHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeCredentialLifecycle) + AddHandler(ctx context.Context, name string, sync SourceCodeCredentialHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeCredentialLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeCredentialHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeCredentialLifecycle) } type sourceCodeCredentialLister struct { @@ -116,34 +116,27 @@ func (c *sourceCodeCredentialController) Lister() SourceCodeCredentialLister { } } -func (c *sourceCodeCredentialController) AddHandler(name string, handler SourceCodeCredentialHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeCredentialController) AddHandler(ctx context.Context, name string, handler SourceCodeCredentialHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeCredential); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*SourceCodeCredential)) }) } -func (c *sourceCodeCredentialController) AddClusterScopedHandler(name, cluster string, handler SourceCodeCredentialHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeCredentialController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SourceCodeCredentialHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeCredential); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*SourceCodeCredential)) }) } @@ -238,20 +231,20 @@ func (s *sourceCodeCredentialClient) DeleteCollection(deleteOpts *metav1.DeleteO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *sourceCodeCredentialClient) AddHandler(name string, sync SourceCodeCredentialHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *sourceCodeCredentialClient) AddHandler(ctx context.Context, name string, sync SourceCodeCredentialHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeCredentialClient) AddLifecycle(name string, lifecycle SourceCodeCredentialLifecycle) { +func (s *sourceCodeCredentialClient) AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeCredentialLifecycle) { sync := NewSourceCodeCredentialLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeCredentialClient) AddClusterScopedHandler(name, clusterName string, sync SourceCodeCredentialHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *sourceCodeCredentialClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeCredentialHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *sourceCodeCredentialClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeCredentialLifecycle) { +func (s *sourceCodeCredentialClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeCredentialLifecycle) { sync := NewSourceCodeCredentialLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_credential_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_source_code_credential_lifecycle_adapter.go index 5b5217ee..d02ae1cc 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_credential_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_credential_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *sourceCodeCredentialLifecycleAdapter) Updated(obj runtime.Object) (runt func NewSourceCodeCredentialLifecycleAdapter(name string, clusterScoped bool, client SourceCodeCredentialInterface, l SourceCodeCredentialLifecycle) SourceCodeCredentialHandlerFunc { adapter := &sourceCodeCredentialLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *SourceCodeCredential) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *SourceCodeCredential) (*SourceCodeCredential, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*SourceCodeCredential); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 86fbfa52..65d98990 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 @@ -35,7 +35,7 @@ type SourceCodeProviderConfigList struct { Items []SourceCodeProviderConfig } -type SourceCodeProviderConfigHandlerFunc func(key string, obj *SourceCodeProviderConfig) error +type SourceCodeProviderConfigHandlerFunc func(key string, obj *SourceCodeProviderConfig) (*SourceCodeProviderConfig, error) type SourceCodeProviderConfigLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeProviderConfig, err error) @@ -46,8 +46,8 @@ type SourceCodeProviderConfigController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SourceCodeProviderConfigLister - AddHandler(name string, handler SourceCodeProviderConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SourceCodeProviderConfigHandlerFunc) + AddHandler(ctx context.Context, name string, handler SourceCodeProviderConfigHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SourceCodeProviderConfigHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type SourceCodeProviderConfigInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SourceCodeProviderConfigController - AddHandler(name string, sync SourceCodeProviderConfigHandlerFunc) - AddLifecycle(name string, lifecycle SourceCodeProviderConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SourceCodeProviderConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeProviderConfigLifecycle) + AddHandler(ctx context.Context, name string, sync SourceCodeProviderConfigHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeProviderConfigLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeProviderConfigHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeProviderConfigLifecycle) } type sourceCodeProviderConfigLister struct { @@ -116,34 +116,27 @@ func (c *sourceCodeProviderConfigController) Lister() SourceCodeProviderConfigLi } } -func (c *sourceCodeProviderConfigController) AddHandler(name string, handler SourceCodeProviderConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeProviderConfigController) AddHandler(ctx context.Context, name string, handler SourceCodeProviderConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeProviderConfig); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*SourceCodeProviderConfig)) }) } -func (c *sourceCodeProviderConfigController) AddClusterScopedHandler(name, cluster string, handler SourceCodeProviderConfigHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeProviderConfigController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SourceCodeProviderConfigHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeProviderConfig); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*SourceCodeProviderConfig)) }) } @@ -238,20 +231,20 @@ func (s *sourceCodeProviderConfigClient) DeleteCollection(deleteOpts *metav1.Del return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *sourceCodeProviderConfigClient) AddHandler(name string, sync SourceCodeProviderConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *sourceCodeProviderConfigClient) AddHandler(ctx context.Context, name string, sync SourceCodeProviderConfigHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeProviderConfigClient) AddLifecycle(name string, lifecycle SourceCodeProviderConfigLifecycle) { +func (s *sourceCodeProviderConfigClient) AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeProviderConfigLifecycle) { sync := NewSourceCodeProviderConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeProviderConfigClient) AddClusterScopedHandler(name, clusterName string, sync SourceCodeProviderConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *sourceCodeProviderConfigClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeProviderConfigHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *sourceCodeProviderConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeProviderConfigLifecycle) { +func (s *sourceCodeProviderConfigClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeProviderConfigLifecycle) { sync := NewSourceCodeProviderConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_lifecycle_adapter.go index 38250ada..7c35b22d 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_provider_config_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *sourceCodeProviderConfigLifecycleAdapter) Updated(obj runtime.Object) ( func NewSourceCodeProviderConfigLifecycleAdapter(name string, clusterScoped bool, client SourceCodeProviderConfigInterface, l SourceCodeProviderConfigLifecycle) SourceCodeProviderConfigHandlerFunc { adapter := &sourceCodeProviderConfigLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *SourceCodeProviderConfig) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *SourceCodeProviderConfig) (*SourceCodeProviderConfig, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*SourceCodeProviderConfig); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 7abc8f2f..c8864ac0 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 @@ -34,7 +34,7 @@ type SourceCodeProviderList struct { Items []SourceCodeProvider } -type SourceCodeProviderHandlerFunc func(key string, obj *SourceCodeProvider) error +type SourceCodeProviderHandlerFunc func(key string, obj *SourceCodeProvider) (*SourceCodeProvider, error) type SourceCodeProviderLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeProvider, err error) @@ -45,8 +45,8 @@ type SourceCodeProviderController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SourceCodeProviderLister - AddHandler(name string, handler SourceCodeProviderHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SourceCodeProviderHandlerFunc) + AddHandler(ctx context.Context, name string, handler SourceCodeProviderHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SourceCodeProviderHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -64,10 +64,10 @@ type SourceCodeProviderInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SourceCodeProviderController - AddHandler(name string, sync SourceCodeProviderHandlerFunc) - AddLifecycle(name string, lifecycle SourceCodeProviderLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SourceCodeProviderHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeProviderLifecycle) + AddHandler(ctx context.Context, name string, sync SourceCodeProviderHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeProviderLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeProviderHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeProviderLifecycle) } type sourceCodeProviderLister struct { @@ -115,34 +115,27 @@ func (c *sourceCodeProviderController) Lister() SourceCodeProviderLister { } } -func (c *sourceCodeProviderController) AddHandler(name string, handler SourceCodeProviderHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeProviderController) AddHandler(ctx context.Context, name string, handler SourceCodeProviderHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeProvider); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*SourceCodeProvider)) }) } -func (c *sourceCodeProviderController) AddClusterScopedHandler(name, cluster string, handler SourceCodeProviderHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeProviderController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SourceCodeProviderHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeProvider); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*SourceCodeProvider)) }) } @@ -237,20 +230,20 @@ func (s *sourceCodeProviderClient) DeleteCollection(deleteOpts *metav1.DeleteOpt return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *sourceCodeProviderClient) AddHandler(name string, sync SourceCodeProviderHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *sourceCodeProviderClient) AddHandler(ctx context.Context, name string, sync SourceCodeProviderHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeProviderClient) AddLifecycle(name string, lifecycle SourceCodeProviderLifecycle) { +func (s *sourceCodeProviderClient) AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeProviderLifecycle) { sync := NewSourceCodeProviderLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeProviderClient) AddClusterScopedHandler(name, clusterName string, sync SourceCodeProviderHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *sourceCodeProviderClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeProviderHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *sourceCodeProviderClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeProviderLifecycle) { +func (s *sourceCodeProviderClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeProviderLifecycle) { sync := NewSourceCodeProviderLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_provider_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_source_code_provider_lifecycle_adapter.go index ec498c20..4bd51fd9 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_provider_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_provider_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *sourceCodeProviderLifecycleAdapter) Updated(obj runtime.Object) (runtim func NewSourceCodeProviderLifecycleAdapter(name string, clusterScoped bool, client SourceCodeProviderInterface, l SourceCodeProviderLifecycle) SourceCodeProviderHandlerFunc { adapter := &sourceCodeProviderLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *SourceCodeProvider) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *SourceCodeProvider) (*SourceCodeProvider, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*SourceCodeProvider); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 acee39ca..7b764f53 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 @@ -35,7 +35,7 @@ type SourceCodeRepositoryList struct { Items []SourceCodeRepository } -type SourceCodeRepositoryHandlerFunc func(key string, obj *SourceCodeRepository) error +type SourceCodeRepositoryHandlerFunc func(key string, obj *SourceCodeRepository) (*SourceCodeRepository, error) type SourceCodeRepositoryLister interface { List(namespace string, selector labels.Selector) (ret []*SourceCodeRepository, err error) @@ -46,8 +46,8 @@ type SourceCodeRepositoryController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SourceCodeRepositoryLister - AddHandler(name string, handler SourceCodeRepositoryHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SourceCodeRepositoryHandlerFunc) + AddHandler(ctx context.Context, name string, handler SourceCodeRepositoryHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SourceCodeRepositoryHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type SourceCodeRepositoryInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SourceCodeRepositoryController - AddHandler(name string, sync SourceCodeRepositoryHandlerFunc) - AddLifecycle(name string, lifecycle SourceCodeRepositoryLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SourceCodeRepositoryHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeRepositoryLifecycle) + AddHandler(ctx context.Context, name string, sync SourceCodeRepositoryHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeRepositoryLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeRepositoryHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeRepositoryLifecycle) } type sourceCodeRepositoryLister struct { @@ -116,34 +116,27 @@ func (c *sourceCodeRepositoryController) Lister() SourceCodeRepositoryLister { } } -func (c *sourceCodeRepositoryController) AddHandler(name string, handler SourceCodeRepositoryHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeRepositoryController) AddHandler(ctx context.Context, name string, handler SourceCodeRepositoryHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeRepository); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*SourceCodeRepository)) }) } -func (c *sourceCodeRepositoryController) AddClusterScopedHandler(name, cluster string, handler SourceCodeRepositoryHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sourceCodeRepositoryController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SourceCodeRepositoryHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SourceCodeRepository); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*SourceCodeRepository)) }) } @@ -238,20 +231,20 @@ func (s *sourceCodeRepositoryClient) DeleteCollection(deleteOpts *metav1.DeleteO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *sourceCodeRepositoryClient) AddHandler(name string, sync SourceCodeRepositoryHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *sourceCodeRepositoryClient) AddHandler(ctx context.Context, name string, sync SourceCodeRepositoryHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeRepositoryClient) AddLifecycle(name string, lifecycle SourceCodeRepositoryLifecycle) { +func (s *sourceCodeRepositoryClient) AddLifecycle(ctx context.Context, name string, lifecycle SourceCodeRepositoryLifecycle) { sync := NewSourceCodeRepositoryLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *sourceCodeRepositoryClient) AddClusterScopedHandler(name, clusterName string, sync SourceCodeRepositoryHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *sourceCodeRepositoryClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SourceCodeRepositoryHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *sourceCodeRepositoryClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SourceCodeRepositoryLifecycle) { +func (s *sourceCodeRepositoryClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SourceCodeRepositoryLifecycle) { sync := NewSourceCodeRepositoryLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_source_code_repository_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_source_code_repository_lifecycle_adapter.go index e21cb1b7..bf2b01c4 100644 --- a/apis/project.cattle.io/v3/zz_generated_source_code_repository_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_source_code_repository_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *sourceCodeRepositoryLifecycleAdapter) Updated(obj runtime.Object) (runt func NewSourceCodeRepositoryLifecycleAdapter(name string, clusterScoped bool, client SourceCodeRepositoryInterface, l SourceCodeRepositoryLifecycle) SourceCodeRepositoryHandlerFunc { adapter := &sourceCodeRepositoryLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *SourceCodeRepository) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *SourceCodeRepository) (*SourceCodeRepository, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*SourceCodeRepository); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 a627f000..a8bd5845 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 @@ -35,7 +35,7 @@ type SSHAuthList struct { Items []SSHAuth } -type SSHAuthHandlerFunc func(key string, obj *SSHAuth) error +type SSHAuthHandlerFunc func(key string, obj *SSHAuth) (*SSHAuth, error) type SSHAuthLister interface { List(namespace string, selector labels.Selector) (ret []*SSHAuth, err error) @@ -46,8 +46,8 @@ type SSHAuthController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() SSHAuthLister - AddHandler(name string, handler SSHAuthHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler SSHAuthHandlerFunc) + AddHandler(ctx context.Context, name string, handler SSHAuthHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler SSHAuthHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type SSHAuthInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() SSHAuthController - AddHandler(name string, sync SSHAuthHandlerFunc) - AddLifecycle(name string, lifecycle SSHAuthLifecycle) - AddClusterScopedHandler(name, clusterName string, sync SSHAuthHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle SSHAuthLifecycle) + AddHandler(ctx context.Context, name string, sync SSHAuthHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle SSHAuthLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SSHAuthHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SSHAuthLifecycle) } type sshAuthLister struct { @@ -116,34 +116,27 @@ func (c *sshAuthController) Lister() SSHAuthLister { } } -func (c *sshAuthController) AddHandler(name string, handler SSHAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sshAuthController) AddHandler(ctx context.Context, name string, handler SSHAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SSHAuth); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*SSHAuth)) }) } -func (c *sshAuthController) AddClusterScopedHandler(name, cluster string, handler SSHAuthHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *sshAuthController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler SSHAuthHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*SSHAuth); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*SSHAuth)) }) } @@ -238,20 +231,20 @@ func (s *sshAuthClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listO return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *sshAuthClient) AddHandler(name string, sync SSHAuthHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *sshAuthClient) AddHandler(ctx context.Context, name string, sync SSHAuthHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *sshAuthClient) AddLifecycle(name string, lifecycle SSHAuthLifecycle) { +func (s *sshAuthClient) AddLifecycle(ctx context.Context, name string, lifecycle SSHAuthLifecycle) { sync := NewSSHAuthLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *sshAuthClient) AddClusterScopedHandler(name, clusterName string, sync SSHAuthHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *sshAuthClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync SSHAuthHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *sshAuthClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle SSHAuthLifecycle) { +func (s *sshAuthClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle SSHAuthLifecycle) { sync := NewSSHAuthLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_ssh_auth_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_ssh_auth_lifecycle_adapter.go index d6a6c905..15797189 100644 --- a/apis/project.cattle.io/v3/zz_generated_ssh_auth_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_ssh_auth_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *sshAuthLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, e func NewSSHAuthLifecycleAdapter(name string, clusterScoped bool, client SSHAuthInterface, l SSHAuthLifecycle) SSHAuthHandlerFunc { adapter := &sshAuthLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *SSHAuth) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *SSHAuth) (*SSHAuth, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*SSHAuth); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 5a1ad065..81549589 100644 --- a/apis/project.cattle.io/v3/zz_generated_workload_controller.go +++ b/apis/project.cattle.io/v3/zz_generated_workload_controller.go @@ -35,7 +35,7 @@ type WorkloadList struct { Items []Workload } -type WorkloadHandlerFunc func(key string, obj *Workload) error +type WorkloadHandlerFunc func(key string, obj *Workload) (*Workload, error) type WorkloadLister interface { List(namespace string, selector labels.Selector) (ret []*Workload, err error) @@ -46,8 +46,8 @@ type WorkloadController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() WorkloadLister - AddHandler(name string, handler WorkloadHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler WorkloadHandlerFunc) + AddHandler(ctx context.Context, name string, handler WorkloadHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler WorkloadHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type WorkloadInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() WorkloadController - AddHandler(name string, sync WorkloadHandlerFunc) - AddLifecycle(name string, lifecycle WorkloadLifecycle) - AddClusterScopedHandler(name, clusterName string, sync WorkloadHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle WorkloadLifecycle) + AddHandler(ctx context.Context, name string, sync WorkloadHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle WorkloadLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync WorkloadHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle WorkloadLifecycle) } type workloadLister struct { @@ -116,34 +116,27 @@ func (c *workloadController) Lister() WorkloadLister { } } -func (c *workloadController) AddHandler(name string, handler WorkloadHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *workloadController) AddHandler(ctx context.Context, name string, handler WorkloadHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Workload); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*Workload)) }) } -func (c *workloadController) AddClusterScopedHandler(name, cluster string, handler WorkloadHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *workloadController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler WorkloadHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*Workload); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*Workload)) }) } @@ -238,20 +231,20 @@ func (s *workloadClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, list return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *workloadClient) AddHandler(name string, sync WorkloadHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *workloadClient) AddHandler(ctx context.Context, name string, sync WorkloadHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *workloadClient) AddLifecycle(name string, lifecycle WorkloadLifecycle) { +func (s *workloadClient) AddLifecycle(ctx context.Context, name string, lifecycle WorkloadLifecycle) { sync := NewWorkloadLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *workloadClient) AddClusterScopedHandler(name, clusterName string, sync WorkloadHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *workloadClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync WorkloadHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *workloadClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle WorkloadLifecycle) { +func (s *workloadClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle WorkloadLifecycle) { sync := NewWorkloadLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/project.cattle.io/v3/zz_generated_workload_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_workload_lifecycle_adapter.go index f2da476d..bf54206f 100644 --- a/apis/project.cattle.io/v3/zz_generated_workload_lifecycle_adapter.go +++ b/apis/project.cattle.io/v3/zz_generated_workload_lifecycle_adapter.go @@ -42,10 +42,11 @@ func (w *workloadLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, func NewWorkloadLifecycleAdapter(name string, clusterScoped bool, client WorkloadInterface, l WorkloadLifecycle) WorkloadHandlerFunc { adapter := &workloadLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *Workload) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *Workload) (*Workload, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*Workload); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 03deaa01..1ce57fc4 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 @@ -35,7 +35,7 @@ type ClusterRoleBindingList struct { Items []v1.ClusterRoleBinding } -type ClusterRoleBindingHandlerFunc func(key string, obj *v1.ClusterRoleBinding) error +type ClusterRoleBindingHandlerFunc func(key string, obj *v1.ClusterRoleBinding) (*v1.ClusterRoleBinding, error) type ClusterRoleBindingLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ClusterRoleBinding, err error) @@ -46,8 +46,8 @@ type ClusterRoleBindingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterRoleBindingLister - AddHandler(name string, handler ClusterRoleBindingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterRoleBindingHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterRoleBindingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterRoleBindingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterRoleBindingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterRoleBindingController - AddHandler(name string, sync ClusterRoleBindingHandlerFunc) - AddLifecycle(name string, lifecycle ClusterRoleBindingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterRoleBindingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRoleBindingLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterRoleBindingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleBindingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleBindingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleBindingLifecycle) } type clusterRoleBindingLister struct { @@ -116,34 +116,27 @@ func (c *clusterRoleBindingController) Lister() ClusterRoleBindingLister { } } -func (c *clusterRoleBindingController) AddHandler(name string, handler ClusterRoleBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRoleBindingController) AddHandler(ctx context.Context, name string, handler ClusterRoleBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ClusterRoleBinding); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ClusterRoleBinding)) }) } -func (c *clusterRoleBindingController) AddClusterScopedHandler(name, cluster string, handler ClusterRoleBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRoleBindingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterRoleBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ClusterRoleBinding); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ClusterRoleBinding)) }) } @@ -238,20 +231,20 @@ func (s *clusterRoleBindingClient) DeleteCollection(deleteOpts *metav1.DeleteOpt return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterRoleBindingClient) AddHandler(name string, sync ClusterRoleBindingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterRoleBindingClient) AddHandler(ctx context.Context, name string, sync ClusterRoleBindingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRoleBindingClient) AddLifecycle(name string, lifecycle ClusterRoleBindingLifecycle) { +func (s *clusterRoleBindingClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleBindingLifecycle) { sync := NewClusterRoleBindingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRoleBindingClient) AddClusterScopedHandler(name, clusterName string, sync ClusterRoleBindingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterRoleBindingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleBindingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterRoleBindingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRoleBindingLifecycle) { +func (s *clusterRoleBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleBindingLifecycle) { sync := NewClusterRoleBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_lifecycle_adapter.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_lifecycle_adapter.go index 05d27789..0e9e84dc 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_lifecycle_adapter.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_binding_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *clusterRoleBindingLifecycleAdapter) Updated(obj runtime.Object) (runtim func NewClusterRoleBindingLifecycleAdapter(name string, clusterScoped bool, client ClusterRoleBindingInterface, l ClusterRoleBindingLifecycle) ClusterRoleBindingHandlerFunc { adapter := &clusterRoleBindingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ClusterRoleBinding) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ClusterRoleBinding) (*v1.ClusterRoleBinding, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ClusterRoleBinding); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 54870210..61ca4fd9 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 @@ -35,7 +35,7 @@ type ClusterRoleList struct { Items []v1.ClusterRole } -type ClusterRoleHandlerFunc func(key string, obj *v1.ClusterRole) error +type ClusterRoleHandlerFunc func(key string, obj *v1.ClusterRole) (*v1.ClusterRole, error) type ClusterRoleLister interface { List(namespace string, selector labels.Selector) (ret []*v1.ClusterRole, err error) @@ -46,8 +46,8 @@ type ClusterRoleController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() ClusterRoleLister - AddHandler(name string, handler ClusterRoleHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterRoleHandlerFunc) + AddHandler(ctx context.Context, name string, handler ClusterRoleHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler ClusterRoleHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -65,10 +65,10 @@ type ClusterRoleInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() ClusterRoleController - AddHandler(name string, sync ClusterRoleHandlerFunc) - AddLifecycle(name string, lifecycle ClusterRoleLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterRoleHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRoleLifecycle) + AddHandler(ctx context.Context, name string, sync ClusterRoleHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleLifecycle) } type clusterRoleLister struct { @@ -116,34 +116,27 @@ func (c *clusterRoleController) Lister() ClusterRoleLister { } } -func (c *clusterRoleController) AddHandler(name string, handler ClusterRoleHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRoleController) AddHandler(ctx context.Context, name string, handler ClusterRoleHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ClusterRole); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.ClusterRole)) }) } -func (c *clusterRoleController) AddClusterScopedHandler(name, cluster string, handler ClusterRoleHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *clusterRoleController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler ClusterRoleHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.ClusterRole); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.ClusterRole)) }) } @@ -238,20 +231,20 @@ func (s *clusterRoleClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, l return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *clusterRoleClient) AddHandler(name string, sync ClusterRoleHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *clusterRoleClient) AddHandler(ctx context.Context, name string, sync ClusterRoleHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRoleClient) AddLifecycle(name string, lifecycle ClusterRoleLifecycle) { +func (s *clusterRoleClient) AddLifecycle(ctx context.Context, name string, lifecycle ClusterRoleLifecycle) { sync := NewClusterRoleLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *clusterRoleClient) AddClusterScopedHandler(name, clusterName string, sync ClusterRoleHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *clusterRoleClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync ClusterRoleHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *clusterRoleClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterRoleLifecycle) { +func (s *clusterRoleClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle ClusterRoleLifecycle) { sync := NewClusterRoleLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_lifecycle_adapter.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_lifecycle_adapter.go index 24557c59..87055d66 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_lifecycle_adapter.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_cluster_role_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *clusterRoleLifecycleAdapter) Updated(obj runtime.Object) (runtime.Objec func NewClusterRoleLifecycleAdapter(name string, clusterScoped bool, client ClusterRoleInterface, l ClusterRoleLifecycle) ClusterRoleHandlerFunc { adapter := &clusterRoleLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.ClusterRole) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.ClusterRole) (*v1.ClusterRole, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.ClusterRole); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 f69ad5ff..c99a7cf6 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 @@ -36,7 +36,7 @@ type RoleBindingList struct { Items []v1.RoleBinding } -type RoleBindingHandlerFunc func(key string, obj *v1.RoleBinding) error +type RoleBindingHandlerFunc func(key string, obj *v1.RoleBinding) (*v1.RoleBinding, error) type RoleBindingLister interface { List(namespace string, selector labels.Selector) (ret []*v1.RoleBinding, err error) @@ -47,8 +47,8 @@ type RoleBindingController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() RoleBindingLister - AddHandler(name string, handler RoleBindingHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler RoleBindingHandlerFunc) + AddHandler(ctx context.Context, name string, handler RoleBindingHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RoleBindingHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type RoleBindingInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() RoleBindingController - AddHandler(name string, sync RoleBindingHandlerFunc) - AddLifecycle(name string, lifecycle RoleBindingLifecycle) - AddClusterScopedHandler(name, clusterName string, sync RoleBindingHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle RoleBindingLifecycle) + AddHandler(ctx context.Context, name string, sync RoleBindingHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle RoleBindingLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleBindingHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleBindingLifecycle) } type roleBindingLister struct { @@ -117,34 +117,27 @@ func (c *roleBindingController) Lister() RoleBindingLister { } } -func (c *roleBindingController) AddHandler(name string, handler RoleBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *roleBindingController) AddHandler(ctx context.Context, name string, handler RoleBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.RoleBinding); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.RoleBinding)) }) } -func (c *roleBindingController) AddClusterScopedHandler(name, cluster string, handler RoleBindingHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *roleBindingController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler RoleBindingHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.RoleBinding); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.RoleBinding)) }) } @@ -239,20 +232,20 @@ func (s *roleBindingClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, l return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *roleBindingClient) AddHandler(name string, sync RoleBindingHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *roleBindingClient) AddHandler(ctx context.Context, name string, sync RoleBindingHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *roleBindingClient) AddLifecycle(name string, lifecycle RoleBindingLifecycle) { +func (s *roleBindingClient) AddLifecycle(ctx context.Context, name string, lifecycle RoleBindingLifecycle) { sync := NewRoleBindingLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *roleBindingClient) AddClusterScopedHandler(name, clusterName string, sync RoleBindingHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *roleBindingClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleBindingHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *roleBindingClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle RoleBindingLifecycle) { +func (s *roleBindingClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleBindingLifecycle) { sync := NewRoleBindingLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_lifecycle_adapter.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_lifecycle_adapter.go index 535ecabe..05915533 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_lifecycle_adapter.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_binding_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *roleBindingLifecycleAdapter) Updated(obj runtime.Object) (runtime.Objec func NewRoleBindingLifecycleAdapter(name string, clusterScoped bool, client RoleBindingInterface, l RoleBindingLifecycle) RoleBindingHandlerFunc { adapter := &roleBindingLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.RoleBinding) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.RoleBinding) (*v1.RoleBinding, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.RoleBinding); ok { + return o, err } - return syncFn(key, obj) + return nil, err } } 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 fa3aa928..1a5315a4 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 @@ -36,7 +36,7 @@ type RoleList struct { Items []v1.Role } -type RoleHandlerFunc func(key string, obj *v1.Role) error +type RoleHandlerFunc func(key string, obj *v1.Role) (*v1.Role, error) type RoleLister interface { List(namespace string, selector labels.Selector) (ret []*v1.Role, err error) @@ -47,8 +47,8 @@ type RoleController interface { Generic() controller.GenericController Informer() cache.SharedIndexInformer Lister() RoleLister - AddHandler(name string, handler RoleHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler RoleHandlerFunc) + AddHandler(ctx context.Context, name string, handler RoleHandlerFunc) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RoleHandlerFunc) Enqueue(namespace, name string) Sync(ctx context.Context) error Start(ctx context.Context, threadiness int) error @@ -66,10 +66,10 @@ type RoleInterface interface { Watch(opts metav1.ListOptions) (watch.Interface, error) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error Controller() RoleController - AddHandler(name string, sync RoleHandlerFunc) - AddLifecycle(name string, lifecycle RoleLifecycle) - AddClusterScopedHandler(name, clusterName string, sync RoleHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle RoleLifecycle) + AddHandler(ctx context.Context, name string, sync RoleHandlerFunc) + AddLifecycle(ctx context.Context, name string, lifecycle RoleLifecycle) + AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleHandlerFunc) + AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleLifecycle) } type roleLister struct { @@ -117,34 +117,27 @@ func (c *roleController) Lister() RoleLister { } } -func (c *roleController) AddHandler(name string, handler RoleHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *roleController) AddHandler(ctx context.Context, name string, handler RoleHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Role); ok { + return handler(key, v) + } else { + return nil, nil } - return handler(key, obj.(*v1.Role)) }) } -func (c *roleController) AddClusterScopedHandler(name, cluster string, handler RoleHandlerFunc) { - c.GenericController.AddHandler(name, func(key string) error { - obj, exists, err := c.Informer().GetStore().GetByKey(key) - if err != nil { - return err - } - if !exists { +func (c *roleController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler RoleHandlerFunc) { + c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) { + if obj == nil { return handler(key, nil) + } else if v, ok := obj.(*v1.Role); ok && controller.ObjectInCluster(cluster, obj) { + return handler(key, v) + } else { + return nil, nil } - - if !controller.ObjectInCluster(cluster, obj) { - return nil - } - - return handler(key, obj.(*v1.Role)) }) } @@ -239,20 +232,20 @@ func (s *roleClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts return s.objectClient.DeleteCollection(deleteOpts, listOpts) } -func (s *roleClient) AddHandler(name string, sync RoleHandlerFunc) { - s.Controller().AddHandler(name, sync) +func (s *roleClient) AddHandler(ctx context.Context, name string, sync RoleHandlerFunc) { + s.Controller().AddHandler(ctx, name, sync) } -func (s *roleClient) AddLifecycle(name string, lifecycle RoleLifecycle) { +func (s *roleClient) AddLifecycle(ctx context.Context, name string, lifecycle RoleLifecycle) { sync := NewRoleLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) + s.Controller().AddHandler(ctx, name, sync) } -func (s *roleClient) AddClusterScopedHandler(name, clusterName string, sync RoleHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) +func (s *roleClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RoleHandlerFunc) { + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } -func (s *roleClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle RoleLifecycle) { +func (s *roleClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RoleLifecycle) { sync := NewRoleLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) + s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync) } diff --git a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_lifecycle_adapter.go b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_lifecycle_adapter.go index 6cb6e0da..15b264d9 100644 --- a/apis/rbac.authorization.k8s.io/v1/zz_generated_role_lifecycle_adapter.go +++ b/apis/rbac.authorization.k8s.io/v1/zz_generated_role_lifecycle_adapter.go @@ -43,10 +43,11 @@ func (w *roleLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, erro func NewRoleLifecycleAdapter(name string, clusterScoped bool, client RoleInterface, l RoleLifecycle) RoleHandlerFunc { adapter := &roleLifecycleAdapter{lifecycle: l} syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *v1.Role) error { - if obj == nil { - return syncFn(key, nil) + return func(key string, obj *v1.Role) (*v1.Role, error) { + newObj, err := syncFn(key, obj) + if o, ok := newObj.(*v1.Role); ok { + return o, err } - return syncFn(key, obj) + return nil, err } }