rancher/types
1
0
Fork 0
mirror of https://github.com/rancher/types.git synced 2025-09-01 13:18:20 +00:00
Code Issues Releases Wiki Activity

Update generated code

Browse Source
This commit is contained in:
Darren Shepherd
2018-10-30 10:06:55 -07:00
parent 641bd0bfd9
commit abee9812f6
172 changed files with 2924 additions and 3440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
apis/apps/v1beta2/zz_generated_daemon_set_controller.go
View File

@@ -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)
}

9
apis/apps/v1beta2/zz_generated_daemon_set_lifecycle_adapter.go
View File

@@ -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
}
}

65
apis/apps/v1beta2/zz_generated_deployment_controller.go
View File

@@ -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)
}

9
apis/apps/v1beta2/zz_generated_deployment_lifecycle_adapter.go
View File

@@ -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
}
}

65
apis/apps/v1beta2/zz_generated_replica_set_controller.go
View File

@@ -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)
}

9
apis/apps/v1beta2/zz_generated_replica_set_lifecycle_adapter.go
View File

@@ -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
}
}

65
apis/apps/v1beta2/zz_generated_stateful_set_controller.go
View File

@@ -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)
}

9
apis/apps/v1beta2/zz_generated_stateful_set_lifecycle_adapter.go
View File

@@ -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
}
}