Merge pull request #375 from galal-hussein/schedule_svclb

pkg/servicelb/controller.go

@@ -21,13 +21,16 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/client-go/kubernetes"
+	v1getter "k8s.io/client-go/kubernetes/typed/apps/v1"
 	coregetter "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 
 const (
-	image        = "rancher/klipper-lb:v0.1.1"
-	svcNameLabel = "svccontroller.k3s.cattle.io/svcname"
-	Ready        = condition.Cond("Ready")
+	image              = "rancher/klipper-lb:v0.1.1"
+	svcNameLabel       = "svccontroller.k3s.cattle.io/svcname"
+	daemonsetNodeLabel = "svccontroller.k3s.cattle.io/enablelb"
+	nodeSelectorLabel  = "svccontroller.k3s.cattle.io/nodeselector"
+	Ready              = condition.Cond("Ready")
 )
 
 var (
@@ -44,12 +47,14 @@ func Register(ctx context.Context, kubernetes kubernetes.Interface, enabled, roo
 		nodeCache: clients.Node.Cache(),
 		podCache:  clients.Pod.Cache(),
 		processor: objectset.NewProcessor("svccontroller").
-			Client(appClients.Deployment),
+			Client(appClients.DaemonSet),
 		serviceCache: clients.Service.Cache(),
 		services:     kubernetes.CoreV1(),
+		daemonsets:   kubernetes.AppsV1(),
 	}
 
-	clients.Service.OnChange(ctx, "svccontroller", h.onChange)
+	clients.Service.OnChange(ctx, "svccontroller", h.onChangeService)
+	clients.Node.OnChange(ctx, "svccontroller", h.onChangeNode)
 	changeset.Watch(ctx, "svccontroller-watcher",
 		h.onResourceChange,
 		clients.Service,
@@ -67,6 +72,7 @@ type handler struct {
 	processor    *objectset.Processor
 	serviceCache coreclient.ServiceClientCache
 	services     coregetter.ServicesGetter
+	daemonsets   v1getter.DaemonSetsGetter
 }
 
 func (h *handler) onResourceChange(name, namespace string, obj runtime.Object) ([]changeset.Key, error) {
@@ -101,7 +107,7 @@ func (h *handler) onResourceChange(name, namespace string, obj runtime.Object) (
 	}, nil
 }
 
-func (h *handler) onChange(svc *core.Service) (runtime.Object, error) {
+func (h *handler) onChangeService(svc *core.Service) (runtime.Object, error) {
 	if svc.Spec.Type != core.ServiceTypeLoadBalancer || svc.Spec.ClusterIP == "" ||
 		svc.Spec.ClusterIP == "None" {
 		return svc, nil
@@ -116,6 +122,18 @@ func (h *handler) onChange(svc *core.Service) (runtime.Object, error) {
 	return nil, err
 }
 
+func (h *handler) onChangeNode(node *core.Node) (runtime.Object, error) {
+	if _, ok := node.Labels[daemonsetNodeLabel]; !ok {
+		return node, nil
+	}
+
+	if err := h.updateDaemonSets(); err != nil {
+		return node, err
+	}
+
+	return node, nil
+}
+
 func (h *handler) updateService(svc *core.Service) (runtime.Object, error) {
 	pods, err := h.podCache.List(svc.Namespace, labels.SelectorFromSet(map[string]string{
 		svcNameLabel: svc.Name,
@@ -200,43 +218,27 @@ func (h *handler) podIPs(pods []*core.Pod) ([]string, error) {
 }
 
 func (h *handler) deployPod(svc *core.Service) error {
+
 	objs := objectset.NewObjectSet()
 	if !h.enabled {
 		return h.processor.NewDesiredSet(svc, objs).Apply()
 	}
 
-	dep, err := h.newDeployment(svc)
+	ds, err := h.newDaemonSet(svc)
 	if err != nil {
 		return err
 	}
-	if dep != nil {
-		objs.Add(dep)
+	if ds != nil {
+		objs.Add(ds)
 	}
-
 	return h.processor.NewDesiredSet(svc, objs).Apply()
 }
 
-func (h *handler) newDeployment(svc *core.Service) (*apps.Deployment, error) {
+func (h *handler) newDaemonSet(svc *core.Service) (*apps.DaemonSet, error) {
 	name := fmt.Sprintf("svclb-%s", svc.Name)
-	zeroInt := intstr.FromInt(0)
 	oneInt := intstr.FromInt(1)
-	replicas := int32(0)
-
-	nodes, err := h.nodeCache.List("", labels.Everything())
-	if err != nil {
-		return nil, err
-	}
 
-	for _, node := range nodes {
-		if Ready.IsTrue(node) {
-			replicas++
-		}
-		if replicas >= 2 {
-			break
-		}
-	}
-
-	dep := &apps.Deployment{
+	ds := &apps.DaemonSet{
 		ObjectMeta: meta.ObjectMeta{
 			Name:      name,
 			Namespace: svc.Namespace,
@@ -249,13 +251,15 @@ func (h *handler) newDeployment(svc *core.Service) (*apps.Deployment, error) {
 					Controller: &trueVal,
 				},
 			},
+			Labels: map[string]string{
+				nodeSelectorLabel: "false",
+			},
 		},
 		TypeMeta: meta.TypeMeta{
-			Kind:       "Deployment",
+			Kind:       "DaemonSet",
 			APIVersion: "apps/v1",
 		},
-		Spec: apps.DeploymentSpec{
-			Replicas: &replicas,
+		Spec: apps.DaemonSetSpec{
 			Selector: &meta.LabelSelector{
 				MatchLabels: map[string]string{
 					"app": name,
@@ -269,10 +273,9 @@ func (h *handler) newDeployment(svc *core.Service) (*apps.Deployment, error) {
 					},
 				},
 			},
-			Strategy: apps.DeploymentStrategy{
-				Type: apps.RollingUpdateDeploymentStrategyType,
-				RollingUpdate: &apps.RollingUpdateDeployment{
-					MaxSurge:       &zeroInt,
+			UpdateStrategy: apps.DaemonSetUpdateStrategy{
+				Type: apps.RollingUpdateDaemonSetStrategyType,
+				RollingUpdate: &apps.RollingUpdateDaemonSet{
 					MaxUnavailable: &oneInt,
 				},
 			},
@@ -319,8 +322,44 @@ func (h *handler) newDeployment(svc *core.Service) (*apps.Deployment, error) {
 			},
 		}
 
-		dep.Spec.Template.Spec.Containers = append(dep.Spec.Template.Spec.Containers, container)
+		ds.Spec.Template.Spec.Containers = append(ds.Spec.Template.Spec.Containers, container)
+	}
+	// Add node selector only if label "svccontroller.k3s.cattle.io/enablelb" exists on the nodes
+	selector, err := labels.Parse(daemonsetNodeLabel)
+	if err != nil {
+		return nil, err
+	}
+	nodesWithLabel, err := h.nodeCache.List("", selector)
+	if err != nil {
+		return nil, err
+	}
+	if len(nodesWithLabel) > 0 {
+		ds.Spec.Template.Spec.NodeSelector = map[string]string{
+			daemonsetNodeLabel: "true",
+		}
+		ds.Labels[nodeSelectorLabel] = "true"
+	}
+	return ds, nil
+}
+
+func (h *handler) updateDaemonSets() error {
+	daemonsets, err := h.daemonsets.DaemonSets("").List(meta.ListOptions{
+		LabelSelector: nodeSelectorLabel + "=false",
+	})
+	if err != nil {
+		return err
+	}
+
+	for _, ds := range daemonsets.Items {
+		ds.Spec.Template.Spec.NodeSelector = map[string]string{
+			daemonsetNodeLabel: "true",
+		}
+		ds.Labels[nodeSelectorLabel] = "true"
+		if _, err := h.daemonsets.DaemonSets(ds.Namespace).Update(&ds); err != nil {
+			return err
+		}
+
 	}
 
-	return dep, nil
+	return nil
 }

types/apis/apps/v1/zz_generated_deployment_controller.go → types/apis/apps/v1/zz_generated_daemon_set_controller.go

@@ -17,83 +17,83 @@ import (
 )
 
 var (
-	DeploymentGroupVersionKind = schema.GroupVersionKind{
+	DaemonSetGroupVersionKind = schema.GroupVersionKind{
 		Version: Version,
 		Group:   GroupName,
-		Kind:    "Deployment",
+		Kind:    "DaemonSet",
 	}
-	DeploymentResource = metav1.APIResource{
-		Name:         "deployments",
-		SingularName: "deployment",
+	DaemonSetResource = metav1.APIResource{
+		Name:         "daemonsets",
+		SingularName: "daemonset",
 		Namespaced:   true,
 
-		Kind: DeploymentGroupVersionKind.Kind,
+		Kind: DaemonSetGroupVersionKind.Kind,
 	}
 )
 
-func NewDeployment(namespace, name string, obj v1.Deployment) *v1.Deployment {
-	obj.APIVersion, obj.Kind = DeploymentGroupVersionKind.ToAPIVersionAndKind()
+func NewDaemonSet(namespace, name string, obj v1.DaemonSet) *v1.DaemonSet {
+	obj.APIVersion, obj.Kind = DaemonSetGroupVersionKind.ToAPIVersionAndKind()
 	obj.Name = name
 	obj.Namespace = namespace
 	return &obj
 }
 
-type DeploymentList struct {
+type DaemonSetList struct {
 	metav1.TypeMeta `json:",inline"`
 	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []v1.Deployment
+	Items           []v1.DaemonSet
 }
 
-type DeploymentHandlerFunc func(key string, obj *v1.Deployment) (runtime.Object, error)
+type DaemonSetHandlerFunc func(key string, obj *v1.DaemonSet) (runtime.Object, error)
 
-type DeploymentChangeHandlerFunc func(obj *v1.Deployment) (runtime.Object, error)
+type DaemonSetChangeHandlerFunc func(obj *v1.DaemonSet) (runtime.Object, error)
 
-type DeploymentLister interface {
-	List(namespace string, selector labels.Selector) (ret []*v1.Deployment, err error)
-	Get(namespace, name string) (*v1.Deployment, error)
+type DaemonSetLister interface {
+	List(namespace string, selector labels.Selector) (ret []*v1.DaemonSet, err error)
+	Get(namespace, name string) (*v1.DaemonSet, error)
 }
 
-type DeploymentController interface {
+type DaemonSetController interface {
 	Generic() controller.GenericController
 	Informer() cache.SharedIndexInformer
-	Lister() DeploymentLister
-	AddHandler(ctx context.Context, name string, handler DeploymentHandlerFunc)
-	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler DeploymentHandlerFunc)
+	Lister() DaemonSetLister
+	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
 }
 
-type DeploymentInterface interface {
+type DaemonSetInterface interface {
 	ObjectClient() *objectclient.ObjectClient
-	Create(*v1.Deployment) (*v1.Deployment, error)
-	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.Deployment, error)
-	Get(name string, opts metav1.GetOptions) (*v1.Deployment, error)
-	Update(*v1.Deployment) (*v1.Deployment, error)
+	Create(*v1.DaemonSet) (*v1.DaemonSet, error)
+	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.DaemonSet, error)
+	Get(name string, opts metav1.GetOptions) (*v1.DaemonSet, error)
+	Update(*v1.DaemonSet) (*v1.DaemonSet, error)
 	Delete(name string, options *metav1.DeleteOptions) error
 	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
-	List(opts metav1.ListOptions) (*DeploymentList, error)
+	List(opts metav1.ListOptions) (*DaemonSetList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Controller() DeploymentController
-	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)
+	Controller() DaemonSetController
+	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 deploymentLister struct {
-	controller *deploymentController
+type daemonSetLister struct {
+	controller *daemonSetController
 }
 
-func (l *deploymentLister) List(namespace string, selector labels.Selector) (ret []*v1.Deployment, err error) {
+func (l *daemonSetLister) List(namespace string, selector labels.Selector) (ret []*v1.DaemonSet, err error) {
 	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
-		ret = append(ret, obj.(*v1.Deployment))
+		ret = append(ret, obj.(*v1.DaemonSet))
 	})
 	return
 }
 
-func (l *deploymentLister) Get(namespace, name string) (*v1.Deployment, error) {
+func (l *daemonSetLister) Get(namespace, name string) (*v1.DaemonSet, error) {
 	var key string
 	if namespace != "" {
 		key = namespace + "/" + name
@@ -106,32 +106,32 @@ func (l *deploymentLister) Get(namespace, name string) (*v1.Deployment, error) {
 	}
 	if !exists {
 		return nil, errors.NewNotFound(schema.GroupResource{
-			Group:    DeploymentGroupVersionKind.Group,
-			Resource: "deployment",
+			Group:    DaemonSetGroupVersionKind.Group,
+			Resource: "daemonSet",
 		}, key)
 	}
-	return obj.(*v1.Deployment), nil
+	return obj.(*v1.DaemonSet), nil
 }
 
-type deploymentController struct {
+type daemonSetController struct {
 	controller.GenericController
 }
 
-func (c *deploymentController) Generic() controller.GenericController {
+func (c *daemonSetController) Generic() controller.GenericController {
 	return c.GenericController
 }
 
-func (c *deploymentController) Lister() DeploymentLister {
-	return &deploymentLister{
+func (c *daemonSetController) Lister() DaemonSetLister {
+	return &daemonSetLister{
 		controller: c,
 	}
 }
 
-func (c *deploymentController) AddHandler(ctx context.Context, name string, handler DeploymentHandlerFunc) {
+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.(*v1.Deployment); ok {
+		} else if v, ok := obj.(*v1.DaemonSet); ok {
 			return handler(key, v)
 		} else {
 			return nil, nil
@@ -139,11 +139,11 @@ func (c *deploymentController) AddHandler(ctx context.Context, name string, hand
 	})
 }
 
-func (c *deploymentController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler DeploymentHandlerFunc) {
+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.(*v1.Deployment); ok && controller.ObjectInCluster(cluster, obj) {
+		} else if v, ok := obj.(*v1.DaemonSet); ok && controller.ObjectInCluster(cluster, obj) {
 			return handler(key, v)
 		} else {
 			return nil, nil
@@ -151,228 +151,228 @@ func (c *deploymentController) AddClusterScopedHandler(ctx context.Context, name
 	})
 }
 
-type deploymentFactory struct {
+type daemonSetFactory struct {
 }
 
-func (c deploymentFactory) Object() runtime.Object {
-	return &v1.Deployment{}
+func (c daemonSetFactory) Object() runtime.Object {
+	return &v1.DaemonSet{}
 }
 
-func (c deploymentFactory) List() runtime.Object {
-	return &DeploymentList{}
+func (c daemonSetFactory) List() runtime.Object {
+	return &DaemonSetList{}
 }
 
-func (s *deploymentClient) Controller() DeploymentController {
+func (s *daemonSetClient) Controller() DaemonSetController {
 	s.client.Lock()
 	defer s.client.Unlock()
 
-	c, ok := s.client.deploymentControllers[s.ns]
+	c, ok := s.client.daemonSetControllers[s.ns]
 	if ok {
 		return c
 	}
 
-	genericController := controller.NewGenericController(DeploymentGroupVersionKind.Kind+"Controller",
+	genericController := controller.NewGenericController(DaemonSetGroupVersionKind.Kind+"Controller",
 		s.objectClient)
 
-	c = &deploymentController{
+	c = &daemonSetController{
 		GenericController: genericController,
 	}
 
-	s.client.deploymentControllers[s.ns] = c
+	s.client.daemonSetControllers[s.ns] = c
 	s.client.starters = append(s.client.starters, c)
 
 	return c
 }
 
-type deploymentClient struct {
+type daemonSetClient struct {
 	client       *Client
 	ns           string
 	objectClient *objectclient.ObjectClient
-	controller   DeploymentController
+	controller   DaemonSetController
 }
 
-func (s *deploymentClient) ObjectClient() *objectclient.ObjectClient {
+func (s *daemonSetClient) ObjectClient() *objectclient.ObjectClient {
 	return s.objectClient
 }
 
-func (s *deploymentClient) Create(o *v1.Deployment) (*v1.Deployment, error) {
+func (s *daemonSetClient) Create(o *v1.DaemonSet) (*v1.DaemonSet, error) {
 	obj, err := s.objectClient.Create(o)
-	return obj.(*v1.Deployment), err
+	return obj.(*v1.DaemonSet), err
 }
 
-func (s *deploymentClient) Get(name string, opts metav1.GetOptions) (*v1.Deployment, error) {
+func (s *daemonSetClient) Get(name string, opts metav1.GetOptions) (*v1.DaemonSet, error) {
 	obj, err := s.objectClient.Get(name, opts)
-	return obj.(*v1.Deployment), err
+	return obj.(*v1.DaemonSet), err
 }
 
-func (s *deploymentClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.Deployment, error) {
+func (s *daemonSetClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.DaemonSet, error) {
 	obj, err := s.objectClient.GetNamespaced(namespace, name, opts)
-	return obj.(*v1.Deployment), err
+	return obj.(*v1.DaemonSet), err
 }
 
-func (s *deploymentClient) Update(o *v1.Deployment) (*v1.Deployment, error) {
+func (s *daemonSetClient) Update(o *v1.DaemonSet) (*v1.DaemonSet, error) {
 	obj, err := s.objectClient.Update(o.Name, o)
-	return obj.(*v1.Deployment), err
+	return obj.(*v1.DaemonSet), err
 }
 
-func (s *deploymentClient) Delete(name string, options *metav1.DeleteOptions) error {
+func (s *daemonSetClient) Delete(name string, options *metav1.DeleteOptions) error {
 	return s.objectClient.Delete(name, options)
 }
 
-func (s *deploymentClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error {
+func (s *daemonSetClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error {
 	return s.objectClient.DeleteNamespaced(namespace, name, options)
 }
 
-func (s *deploymentClient) List(opts metav1.ListOptions) (*DeploymentList, error) {
+func (s *daemonSetClient) List(opts metav1.ListOptions) (*DaemonSetList, error) {
 	obj, err := s.objectClient.List(opts)
-	return obj.(*DeploymentList), err
+	return obj.(*DaemonSetList), err
 }
 
-func (s *deploymentClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+func (s *daemonSetClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return s.objectClient.Watch(opts)
 }
 
 // Patch applies the patch and returns the patched deployment.
-func (s *deploymentClient) Patch(o *v1.Deployment, patchType types.PatchType, data []byte, subresources ...string) (*v1.Deployment, error) {
+func (s *daemonSetClient) Patch(o *v1.DaemonSet, patchType types.PatchType, data []byte, subresources ...string) (*v1.DaemonSet, error) {
 	obj, err := s.objectClient.Patch(o.Name, o, patchType, data, subresources...)
-	return obj.(*v1.Deployment), err
+	return obj.(*v1.DaemonSet), err
 }
 
-func (s *deploymentClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
+func (s *daemonSetClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
 	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
 }
 
-func (s *deploymentClient) AddHandler(ctx context.Context, name string, sync DeploymentHandlerFunc) {
+func (s *daemonSetClient) AddHandler(ctx context.Context, name string, sync DaemonSetHandlerFunc) {
 	s.Controller().AddHandler(ctx, name, sync)
 }
 
-func (s *deploymentClient) AddLifecycle(ctx context.Context, name string, lifecycle DeploymentLifecycle) {
-	sync := NewDeploymentLifecycleAdapter(name, false, s, lifecycle)
+func (s *daemonSetClient) AddLifecycle(ctx context.Context, name string, lifecycle DaemonSetLifecycle) {
+	sync := NewDaemonSetLifecycleAdapter(name, false, s, lifecycle)
 	s.Controller().AddHandler(ctx, name, sync)
 }
 
-func (s *deploymentClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DeploymentHandlerFunc) {
+func (s *daemonSetClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync DaemonSetHandlerFunc) {
 	s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync)
 }
 
-func (s *deploymentClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DeploymentLifecycle) {
-	sync := NewDeploymentLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle)
+func (s *daemonSetClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle DaemonSetLifecycle) {
+	sync := NewDaemonSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle)
 	s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync)
 }
 
-type DeploymentIndexer func(obj *v1.Deployment) ([]string, error)
+type DaemonSetIndexer func(obj *v1.DaemonSet) ([]string, error)
 
-type DeploymentClientCache interface {
-	Get(namespace, name string) (*v1.Deployment, error)
-	List(namespace string, selector labels.Selector) ([]*v1.Deployment, error)
+type DaemonSetClientCache interface {
+	Get(namespace, name string) (*v1.DaemonSet, error)
+	List(namespace string, selector labels.Selector) ([]*v1.DaemonSet, error)
 
-	Index(name string, indexer DeploymentIndexer)
-	GetIndexed(name, key string) ([]*v1.Deployment, error)
+	Index(name string, indexer DaemonSetIndexer)
+	GetIndexed(name, key string) ([]*v1.DaemonSet, error)
 }
 
-type DeploymentClient interface {
-	Create(*v1.Deployment) (*v1.Deployment, error)
-	Get(namespace, name string, opts metav1.GetOptions) (*v1.Deployment, error)
-	Update(*v1.Deployment) (*v1.Deployment, error)
+type DaemonSetClient interface {
+	Create(*v1.DaemonSet) (*v1.DaemonSet, error)
+	Get(namespace, name string, opts metav1.GetOptions) (*v1.DaemonSet, error)
+	Update(*v1.DaemonSet) (*v1.DaemonSet, error)
 	Delete(namespace, name string, options *metav1.DeleteOptions) error
-	List(namespace string, opts metav1.ListOptions) (*DeploymentList, error)
+	List(namespace string, opts metav1.ListOptions) (*DaemonSetList, error)
 	Watch(opts metav1.ListOptions) (watch.Interface, error)
 
-	Cache() DeploymentClientCache
+	Cache() DaemonSetClientCache
 
-	OnCreate(ctx context.Context, name string, sync DeploymentChangeHandlerFunc)
-	OnChange(ctx context.Context, name string, sync DeploymentChangeHandlerFunc)
-	OnRemove(ctx context.Context, name string, sync DeploymentChangeHandlerFunc)
+	OnCreate(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc)
+	OnChange(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc)
+	OnRemove(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc)
 	Enqueue(namespace, name string)
 
 	Generic() controller.GenericController
 	ObjectClient() *objectclient.ObjectClient
-	Interface() DeploymentInterface
+	Interface() DaemonSetInterface
 }
 
-type deploymentClientCache struct {
-	client *deploymentClient2
+type daemonSetClientCache struct {
+	client *daemonSetClient2
 }
 
-type deploymentClient2 struct {
-	iface      DeploymentInterface
-	controller DeploymentController
+type daemonSetClient2 struct {
+	iface      DaemonSetInterface
+	controller DaemonSetController
 }
 
-func (n *deploymentClient2) Interface() DeploymentInterface {
+func (n *daemonSetClient2) Interface() DaemonSetInterface {
 	return n.iface
 }
 
-func (n *deploymentClient2) Generic() controller.GenericController {
+func (n *daemonSetClient2) Generic() controller.GenericController {
 	return n.iface.Controller().Generic()
 }
 
-func (n *deploymentClient2) ObjectClient() *objectclient.ObjectClient {
+func (n *daemonSetClient2) ObjectClient() *objectclient.ObjectClient {
 	return n.Interface().ObjectClient()
 }
 
-func (n *deploymentClient2) Enqueue(namespace, name string) {
+func (n *daemonSetClient2) Enqueue(namespace, name string) {
 	n.iface.Controller().Enqueue(namespace, name)
 }
 
-func (n *deploymentClient2) Create(obj *v1.Deployment) (*v1.Deployment, error) {
+func (n *daemonSetClient2) Create(obj *v1.DaemonSet) (*v1.DaemonSet, error) {
 	return n.iface.Create(obj)
 }
 
-func (n *deploymentClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.Deployment, error) {
+func (n *daemonSetClient2) Get(namespace, name string, opts metav1.GetOptions) (*v1.DaemonSet, error) {
 	return n.iface.GetNamespaced(namespace, name, opts)
 }
 
-func (n *deploymentClient2) Update(obj *v1.Deployment) (*v1.Deployment, error) {
+func (n *daemonSetClient2) Update(obj *v1.DaemonSet) (*v1.DaemonSet, error) {
 	return n.iface.Update(obj)
 }
 
-func (n *deploymentClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error {
+func (n *daemonSetClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error {
 	return n.iface.DeleteNamespaced(namespace, name, options)
 }
 
-func (n *deploymentClient2) List(namespace string, opts metav1.ListOptions) (*DeploymentList, error) {
+func (n *daemonSetClient2) List(namespace string, opts metav1.ListOptions) (*DaemonSetList, error) {
 	return n.iface.List(opts)
 }
 
-func (n *deploymentClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+func (n *daemonSetClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	return n.iface.Watch(opts)
 }
 
-func (n *deploymentClientCache) Get(namespace, name string) (*v1.Deployment, error) {
+func (n *daemonSetClientCache) Get(namespace, name string) (*v1.DaemonSet, error) {
 	return n.client.controller.Lister().Get(namespace, name)
 }
 
-func (n *deploymentClientCache) List(namespace string, selector labels.Selector) ([]*v1.Deployment, error) {
+func (n *daemonSetClientCache) List(namespace string, selector labels.Selector) ([]*v1.DaemonSet, error) {
 	return n.client.controller.Lister().List(namespace, selector)
 }
 
-func (n *deploymentClient2) Cache() DeploymentClientCache {
+func (n *daemonSetClient2) Cache() DaemonSetClientCache {
 	n.loadController()
-	return &deploymentClientCache{
+	return &daemonSetClientCache{
 		client: n,
 	}
 }
 
-func (n *deploymentClient2) OnCreate(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) {
+func (n *daemonSetClient2) OnCreate(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) {
 	n.loadController()
-	n.iface.AddLifecycle(ctx, name+"-create", &deploymentLifecycleDelegate{create: sync})
+	n.iface.AddLifecycle(ctx, name+"-create", &daemonSetLifecycleDelegate{create: sync})
 }
 
-func (n *deploymentClient2) OnChange(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) {
+func (n *daemonSetClient2) OnChange(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) {
 	n.loadController()
-	n.iface.AddLifecycle(ctx, name+"-change", &deploymentLifecycleDelegate{update: sync})
+	n.iface.AddLifecycle(ctx, name+"-change", &daemonSetLifecycleDelegate{update: sync})
 }
 
-func (n *deploymentClient2) OnRemove(ctx context.Context, name string, sync DeploymentChangeHandlerFunc) {
+func (n *daemonSetClient2) OnRemove(ctx context.Context, name string, sync DaemonSetChangeHandlerFunc) {
 	n.loadController()
-	n.iface.AddLifecycle(ctx, name, &deploymentLifecycleDelegate{remove: sync})
+	n.iface.AddLifecycle(ctx, name, &daemonSetLifecycleDelegate{remove: sync})
 }
 
-func (n *deploymentClientCache) Index(name string, indexer DeploymentIndexer) {
+func (n *daemonSetClientCache) Index(name string, indexer DaemonSetIndexer) {
 	err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{
 		name: func(obj interface{}) ([]string, error) {
-			if v, ok := obj.(*v1.Deployment); ok {
+			if v, ok := obj.(*v1.DaemonSet); ok {
 				return indexer(v)
 			}
 			return nil, nil
@@ -384,14 +384,14 @@ func (n *deploymentClientCache) Index(name string, indexer DeploymentIndexer) {
 	}
 }
 
-func (n *deploymentClientCache) GetIndexed(name, key string) ([]*v1.Deployment, error) {
-	var result []*v1.Deployment
+func (n *daemonSetClientCache) GetIndexed(name, key string) ([]*v1.DaemonSet, error) {
+	var result []*v1.DaemonSet
 	objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key)
 	if err != nil {
 		return nil, err
 	}
 	for _, obj := range objs {
-		if v, ok := obj.(*v1.Deployment); ok {
+		if v, ok := obj.(*v1.DaemonSet); ok {
 			result = append(result, v)
 		}
 	}
@@ -399,41 +399,41 @@ func (n *deploymentClientCache) GetIndexed(name, key string) ([]*v1.Deployment,
 	return result, nil
 }
 
-func (n *deploymentClient2) loadController() {
+func (n *daemonSetClient2) loadController() {
 	if n.controller == nil {
 		n.controller = n.iface.Controller()
 	}
 }
 
-type deploymentLifecycleDelegate struct {
-	create DeploymentChangeHandlerFunc
-	update DeploymentChangeHandlerFunc
-	remove DeploymentChangeHandlerFunc
+type daemonSetLifecycleDelegate struct {
+	create DaemonSetChangeHandlerFunc
+	update DaemonSetChangeHandlerFunc
+	remove DaemonSetChangeHandlerFunc
 }
 
-func (n *deploymentLifecycleDelegate) HasCreate() bool {
+func (n *daemonSetLifecycleDelegate) HasCreate() bool {
 	return n.create != nil
 }
 
-func (n *deploymentLifecycleDelegate) Create(obj *v1.Deployment) (runtime.Object, error) {
+func (n *daemonSetLifecycleDelegate) Create(obj *v1.DaemonSet) (runtime.Object, error) {
 	if n.create == nil {
 		return obj, nil
 	}
 	return n.create(obj)
 }
 
-func (n *deploymentLifecycleDelegate) HasFinalize() bool {
+func (n *daemonSetLifecycleDelegate) HasFinalize() bool {
 	return n.remove != nil
 }
 
-func (n *deploymentLifecycleDelegate) Remove(obj *v1.Deployment) (runtime.Object, error) {
+func (n *daemonSetLifecycleDelegate) Remove(obj *v1.DaemonSet) (runtime.Object, error) {
 	if n.remove == nil {
 		return obj, nil
 	}
 	return n.remove(obj)
 }
 
-func (n *deploymentLifecycleDelegate) Updated(obj *v1.Deployment) (runtime.Object, error) {
+func (n *daemonSetLifecycleDelegate) Updated(obj *v1.DaemonSet) (runtime.Object, error) {
 	if n.update == nil {
 		return obj, nil
 	}

types/apis/apps/v1/zz_generated_deployment_lifecycle_adapter.go → types/apis/apps/v1/zz_generated_daemon_set_lifecycle_adapter.go

@@ -6,54 +6,54 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 )
 
-type DeploymentLifecycle interface {
-	Create(obj *v1.Deployment) (runtime.Object, error)
-	Remove(obj *v1.Deployment) (runtime.Object, error)
-	Updated(obj *v1.Deployment) (runtime.Object, error)
+type DaemonSetLifecycle interface {
+	Create(obj *v1.DaemonSet) (runtime.Object, error)
+	Remove(obj *v1.DaemonSet) (runtime.Object, error)
+	Updated(obj *v1.DaemonSet) (runtime.Object, error)
 }
 
-type deploymentLifecycleAdapter struct {
-	lifecycle DeploymentLifecycle
+type daemonSetLifecycleAdapter struct {
+	lifecycle DaemonSetLifecycle
 }
 
-func (w *deploymentLifecycleAdapter) HasCreate() bool {
+func (w *daemonSetLifecycleAdapter) HasCreate() bool {
 	o, ok := w.lifecycle.(lifecycle.ObjectLifecycleCondition)
 	return !ok || o.HasCreate()
 }
 
-func (w *deploymentLifecycleAdapter) HasFinalize() bool {
+func (w *daemonSetLifecycleAdapter) HasFinalize() bool {
 	o, ok := w.lifecycle.(lifecycle.ObjectLifecycleCondition)
 	return !ok || o.HasFinalize()
 }
 
-func (w *deploymentLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
-	o, err := w.lifecycle.Create(obj.(*v1.Deployment))
+func (w *daemonSetLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Create(obj.(*v1.DaemonSet))
 	if o == nil {
 		return nil, err
 	}
 	return o, err
 }
 
-func (w *deploymentLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
-	o, err := w.lifecycle.Remove(obj.(*v1.Deployment))
+func (w *daemonSetLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Remove(obj.(*v1.DaemonSet))
 	if o == nil {
 		return nil, err
 	}
 	return o, err
 }
 
-func (w *deploymentLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
-	o, err := w.lifecycle.Updated(obj.(*v1.Deployment))
+func (w *daemonSetLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
+	o, err := w.lifecycle.Updated(obj.(*v1.DaemonSet))
 	if o == nil {
 		return nil, err
 	}
 	return o, err
 }
 
-func NewDeploymentLifecycleAdapter(name string, clusterScoped bool, client DeploymentInterface, l DeploymentLifecycle) DeploymentHandlerFunc {
-	adapter := &deploymentLifecycleAdapter{lifecycle: l}
+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 *v1.Deployment) (runtime.Object, error) {
+	return func(key string, obj *v1.DaemonSet) (runtime.Object, error) {
 		newObj, err := syncFn(key, obj)
 		if o, ok := newObj.(runtime.Object); ok {
 			return o, err

types/apis/apps/v1/zz_generated_deepcopy.go

@@ -6,13 +6,13 @@ import (
 )
 
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *DeploymentList) DeepCopyInto(out *DeploymentList) {
+func (in *DaemonSetList) DeepCopyInto(out *DaemonSetList) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta
 	out.ListMeta = in.ListMeta
 	if in.Items != nil {
 		in, out := &in.Items, &out.Items
-		*out = make([]appsv1.Deployment, len(*in))
+		*out = make([]appsv1.DaemonSet, len(*in))
 		for i := range *in {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
@@ -20,18 +20,18 @@ func (in *DeploymentList) DeepCopyInto(out *DeploymentList) {
 	return
 }
 
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentList.
-func (in *DeploymentList) DeepCopy() *DeploymentList {
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetList.
+func (in *DaemonSetList) DeepCopy() *DaemonSetList {
 	if in == nil {
 		return nil
 	}
-	out := new(DeploymentList)
+	out := new(DaemonSetList)
 	in.DeepCopyInto(out)
 	return out
 }
 
 // DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *DeploymentList) DeepCopyObject() runtime.Object {
+func (in *DaemonSetList) DeepCopyObject() runtime.Object {
 	if c := in.DeepCopy(); c != nil {
 		return c
 	}

types/apis/apps/v1/zz_generated_k8s_client.go

@@ -20,13 +20,13 @@ type Interface interface {
 	RESTClient() rest.Interface
 	controller.Starter
 
-	DeploymentsGetter
+	DaemonSetsGetter
 }
 
 type Clients struct {
 	Interface Interface
 
-	Deployment DeploymentClient
+	DaemonSet DaemonSetClient
 }
 
 type Client struct {
@@ -34,7 +34,7 @@ type Client struct {
 	restClient rest.Interface
 	starters   []controller.Starter
 
-	deploymentControllers map[string]DeploymentController
+	daemonSetControllers map[string]DaemonSetController
 }
 
 func Factory(ctx context.Context, config rest.Config) (context.Context, controller.Starter, error) {
@@ -70,8 +70,8 @@ func NewClientsFromInterface(iface Interface) *Clients {
 	return &Clients{
 		Interface: iface,
 
-		Deployment: &deploymentClient2{
-			iface: iface.Deployments(""),
+		DaemonSet: &daemonSetClient2{
+			iface: iface.DaemonSets(""),
 		},
 	}
 }
@@ -89,7 +89,7 @@ func NewForConfig(config rest.Config) (Interface, error) {
 	return &Client{
 		restClient: restClient,
 
-		deploymentControllers: map[string]DeploymentController{},
+		daemonSetControllers: map[string]DaemonSetController{},
 	}, nil
 }
 
@@ -105,13 +105,13 @@ func (c *Client) Start(ctx context.Context, threadiness int) error {
 	return controller.Start(ctx, threadiness, c.starters...)
 }
 
-type DeploymentsGetter interface {
-	Deployments(namespace string) DeploymentInterface
+type DaemonSetsGetter interface {
+	DaemonSets(namespace string) DaemonSetInterface
 }
 
-func (c *Client) Deployments(namespace string) DeploymentInterface {
-	objectClient := objectclient.NewObjectClient(namespace, c.restClient, &DeploymentResource, DeploymentGroupVersionKind, deploymentFactory{})
-	return &deploymentClient{
+func (c *Client) DaemonSets(namespace string) DaemonSetInterface {
+	objectClient := objectclient.NewObjectClient(namespace, c.restClient, &DaemonSetResource, DaemonSetGroupVersionKind, daemonSetFactory{})
+	return &daemonSetClient{
 		ns:           namespace,
 		client:       c,
 		objectClient: objectClient,

types/apis/apps/v1/zz_generated_scheme.go

@@ -33,7 +33,7 @@ func addKnownTypes(scheme *runtime.Scheme) error {
 	// TODO this gets cleaned up when the types are fixed
 	scheme.AddKnownTypes(SchemeGroupVersion,
 
-		&DeploymentList{},
+		&DaemonSetList{},
 	)
 	return nil
 }

types/codegen/main.go

@@ -99,7 +99,7 @@ func main() {
 	}
 
 	if err := generator.ControllersForForeignTypes(basePackage, appsv1.SchemeGroupVersion, []interface{}{
-		appsv1.Deployment{},
+		appsv1.DaemonSet{},
 	}, nil); err != nil {
 		logrus.Fatal(err)
 	}