diff --git a/apis/apps/v1beta2/zz_generated_deepcopy.go b/apis/apps/v1beta2/zz_generated_deepcopy.go index 609baa60..653591a9 100644 --- a/apis/apps/v1beta2/zz_generated_deepcopy.go +++ b/apis/apps/v1beta2/zz_generated_deepcopy.go @@ -26,6 +26,10 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*DeploymentList).DeepCopyInto(out.(*DeploymentList)) return nil }, InType: reflect.TypeOf(&DeploymentList{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ReplicaSetList).DeepCopyInto(out.(*ReplicaSetList)) + return nil + }, InType: reflect.TypeOf(&ReplicaSetList{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*StatefulSetList).DeepCopyInto(out.(*StatefulSetList)) return nil @@ -101,6 +105,40 @@ func (in *DeploymentList) DeepCopyObject() runtime.Object { } } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ReplicaSetList) DeepCopyInto(out *ReplicaSetList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]apps_v1beta2.ReplicaSet, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicaSetList. +func (in *ReplicaSetList) DeepCopy() *ReplicaSetList { + if in == nil { + return nil + } + out := new(ReplicaSetList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ReplicaSetList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *StatefulSetList) DeepCopyInto(out *StatefulSetList) { *out = *in diff --git a/apis/apps/v1beta2/zz_generated_k8s_client.go b/apis/apps/v1beta2/zz_generated_k8s_client.go index 43ccadf5..01b2efb1 100644 --- a/apis/apps/v1beta2/zz_generated_k8s_client.go +++ b/apis/apps/v1beta2/zz_generated_k8s_client.go @@ -17,6 +17,7 @@ type Interface interface { DeploymentsGetter DaemonSetsGetter StatefulSetsGetter + ReplicaSetsGetter } type Client struct { @@ -27,6 +28,7 @@ type Client struct { deploymentControllers map[string]DeploymentController daemonSetControllers map[string]DaemonSetController statefulSetControllers map[string]StatefulSetController + replicaSetControllers map[string]ReplicaSetController } func NewForConfig(config rest.Config) (Interface, error) { @@ -46,6 +48,7 @@ func NewForConfig(config rest.Config) (Interface, error) { deploymentControllers: map[string]DeploymentController{}, daemonSetControllers: map[string]DaemonSetController{}, statefulSetControllers: map[string]StatefulSetController{}, + replicaSetControllers: map[string]ReplicaSetController{}, }, nil } @@ -99,3 +102,16 @@ func (c *Client) StatefulSets(namespace string) StatefulSetInterface { objectClient: objectClient, } } + +type ReplicaSetsGetter interface { + ReplicaSets(namespace string) ReplicaSetInterface +} + +func (c *Client) ReplicaSets(namespace string) ReplicaSetInterface { + objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ReplicaSetResource, ReplicaSetGroupVersionKind, replicaSetFactory{}) + return &replicaSetClient{ + ns: namespace, + client: c, + objectClient: objectClient, + } +} diff --git a/apis/apps/v1beta2/zz_generated_replica_set_controller.go b/apis/apps/v1beta2/zz_generated_replica_set_controller.go new file mode 100644 index 00000000..4290eaa1 --- /dev/null +++ b/apis/apps/v1beta2/zz_generated_replica_set_controller.go @@ -0,0 +1,253 @@ +package v1beta2 + +import ( + "context" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/api/apps/v1beta2" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" +) + +var ( + ReplicaSetGroupVersionKind = schema.GroupVersionKind{ + Version: Version, + Group: GroupName, + Kind: "ReplicaSet", + } + ReplicaSetResource = metav1.APIResource{ + Name: "replicasets", + SingularName: "replicaset", + Namespaced: true, + + Kind: ReplicaSetGroupVersionKind.Kind, + } +) + +type ReplicaSetList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []v1beta2.ReplicaSet +} + +type ReplicaSetHandlerFunc func(key string, obj *v1beta2.ReplicaSet) error + +type ReplicaSetLister interface { + List(namespace string, selector labels.Selector) (ret []*v1beta2.ReplicaSet, err error) + Get(namespace, name string) (*v1beta2.ReplicaSet, error) +} + +type ReplicaSetController interface { + Informer() cache.SharedIndexInformer + Lister() ReplicaSetLister + AddHandler(name string, handler ReplicaSetHandlerFunc) + AddClusterScopedHandler(name, clusterName string, handler ReplicaSetHandlerFunc) + Enqueue(namespace, name string) + Sync(ctx context.Context) error + Start(ctx context.Context, threadiness int) error +} + +type ReplicaSetInterface interface { + ObjectClient() *clientbase.ObjectClient + Create(*v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) + GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1beta2.ReplicaSet, error) + Get(name string, opts metav1.GetOptions) (*v1beta2.ReplicaSet, error) + Update(*v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) + Delete(name string, options *metav1.DeleteOptions) error + DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error + List(opts metav1.ListOptions) (*ReplicaSetList, error) + 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) +} + +type replicaSetLister struct { + controller *replicaSetController +} + +func (l *replicaSetLister) List(namespace string, selector labels.Selector) (ret []*v1beta2.ReplicaSet, err error) { + err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { + ret = append(ret, obj.(*v1beta2.ReplicaSet)) + }) + return +} + +func (l *replicaSetLister) Get(namespace, name string) (*v1beta2.ReplicaSet, error) { + var key string + if namespace != "" { + key = namespace + "/" + name + } else { + key = name + } + obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(schema.GroupResource{ + Group: ReplicaSetGroupVersionKind.Group, + Resource: "replicaSet", + }, name) + } + return obj.(*v1beta2.ReplicaSet), nil +} + +type replicaSetController struct { + controller.GenericController +} + +func (c *replicaSetController) Lister() ReplicaSetLister { + return &replicaSetLister{ + controller: c, + } +} + +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 { + return handler(key, 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 { + return handler(key, nil) + } + + if !controller.ObjectInCluster(cluster, obj) { + return nil + } + + return handler(key, obj.(*v1beta2.ReplicaSet)) + }) +} + +type replicaSetFactory struct { +} + +func (c replicaSetFactory) Object() runtime.Object { + return &v1beta2.ReplicaSet{} +} + +func (c replicaSetFactory) List() runtime.Object { + return &ReplicaSetList{} +} + +func (s *replicaSetClient) Controller() ReplicaSetController { + s.client.Lock() + defer s.client.Unlock() + + c, ok := s.client.replicaSetControllers[s.ns] + if ok { + return c + } + + genericController := controller.NewGenericController(ReplicaSetGroupVersionKind.Kind+"Controller", + s.objectClient) + + c = &replicaSetController{ + GenericController: genericController, + } + + s.client.replicaSetControllers[s.ns] = c + s.client.starters = append(s.client.starters, c) + + return c +} + +type replicaSetClient struct { + client *Client + ns string + objectClient *clientbase.ObjectClient + controller ReplicaSetController +} + +func (s *replicaSetClient) ObjectClient() *clientbase.ObjectClient { + return s.objectClient +} + +func (s *replicaSetClient) Create(o *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) { + obj, err := s.objectClient.Create(o) + return obj.(*v1beta2.ReplicaSet), err +} + +func (s *replicaSetClient) Get(name string, opts metav1.GetOptions) (*v1beta2.ReplicaSet, error) { + obj, err := s.objectClient.Get(name, opts) + return obj.(*v1beta2.ReplicaSet), err +} + +func (s *replicaSetClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1beta2.ReplicaSet, error) { + obj, err := s.objectClient.GetNamespaced(namespace, name, opts) + return obj.(*v1beta2.ReplicaSet), err +} + +func (s *replicaSetClient) Update(o *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) { + obj, err := s.objectClient.Update(o.Name, o) + return obj.(*v1beta2.ReplicaSet), err +} + +func (s *replicaSetClient) Delete(name string, options *metav1.DeleteOptions) error { + return s.objectClient.Delete(name, options) +} + +func (s *replicaSetClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { + return s.objectClient.DeleteNamespaced(namespace, name, options) +} + +func (s *replicaSetClient) List(opts metav1.ListOptions) (*ReplicaSetList, error) { + obj, err := s.objectClient.List(opts) + return obj.(*ReplicaSetList), err +} + +func (s *replicaSetClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return s.objectClient.Watch(opts) +} + +// Patch applies the patch and returns the patched deployment. +func (s *replicaSetClient) Patch(o *v1beta2.ReplicaSet, data []byte, subresources ...string) (*v1beta2.ReplicaSet, error) { + obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) + return obj.(*v1beta2.ReplicaSet), err +} + +func (s *replicaSetClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { + return s.objectClient.DeleteCollection(deleteOpts, listOpts) +} + +func (s *replicaSetClient) AddHandler(name string, sync ReplicaSetHandlerFunc) { + s.Controller().AddHandler(name, sync) +} + +func (s *replicaSetClient) AddLifecycle(name string, lifecycle ReplicaSetLifecycle) { + sync := NewReplicaSetLifecycleAdapter(name, false, s, lifecycle) + s.AddHandler(name, sync) +} + +func (s *replicaSetClient) AddClusterScopedHandler(name, clusterName string, sync ReplicaSetHandlerFunc) { + s.Controller().AddClusterScopedHandler(name, clusterName, sync) +} + +func (s *replicaSetClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ReplicaSetLifecycle) { + sync := NewReplicaSetLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) + s.AddClusterScopedHandler(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 new file mode 100644 index 00000000..851161e6 --- /dev/null +++ b/apis/apps/v1beta2/zz_generated_replica_set_lifecycle_adapter.go @@ -0,0 +1,52 @@ +package v1beta2 + +import ( + "github.com/rancher/norman/lifecycle" + "k8s.io/api/apps/v1beta2" + "k8s.io/apimachinery/pkg/runtime" +) + +type ReplicaSetLifecycle interface { + Create(obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) + Remove(obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) + Updated(obj *v1beta2.ReplicaSet) (*v1beta2.ReplicaSet, error) +} + +type replicaSetLifecycleAdapter struct { + lifecycle ReplicaSetLifecycle +} + +func (w *replicaSetLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Create(obj.(*v1beta2.ReplicaSet)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *replicaSetLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Remove(obj.(*v1beta2.ReplicaSet)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *replicaSetLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Updated(obj.(*v1beta2.ReplicaSet)) + if o == nil { + return nil, err + } + return o, err +} + +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 syncFn(key, obj) + } +} diff --git a/apis/apps/v1beta2/zz_generated_scheme.go b/apis/apps/v1beta2/zz_generated_scheme.go index b425547d..530b67ae 100644 --- a/apis/apps/v1beta2/zz_generated_scheme.go +++ b/apis/apps/v1beta2/zz_generated_scheme.go @@ -36,6 +36,7 @@ func addKnownTypes(scheme *runtime.Scheme) error { &DeploymentList{}, &DaemonSetList{}, &StatefulSetList{}, + &ReplicaSetList{}, ) return nil } diff --git a/apis/batch/v1/zz_generated_deepcopy.go b/apis/batch/v1/zz_generated_deepcopy.go new file mode 100644 index 00000000..1c6f813c --- /dev/null +++ b/apis/batch/v1/zz_generated_deepcopy.go @@ -0,0 +1,60 @@ +package v1 + +import ( + reflect "reflect" + + batch_v1 "k8s.io/api/batch/v1" + conversion "k8s.io/apimachinery/pkg/conversion" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +func init() { + SchemeBuilder.Register(RegisterDeepCopies) +} + +// RegisterDeepCopies adds deep-copy functions to the given scheme. Public +// to allow building arbitrary schemes. +// +// Deprecated: deepcopy registration will go away when static deepcopy is fully implemented. +func RegisterDeepCopies(scheme *runtime.Scheme) error { + return scheme.AddGeneratedDeepCopyFuncs( + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JobList).DeepCopyInto(out.(*JobList)) + return nil + }, InType: reflect.TypeOf(&JobList{})}, + ) +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JobList) DeepCopyInto(out *JobList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]batch_v1.Job, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobList. +func (in *JobList) DeepCopy() *JobList { + if in == nil { + return nil + } + out := new(JobList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *JobList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} diff --git a/apis/batch/v1/zz_generated_job_controller.go b/apis/batch/v1/zz_generated_job_controller.go new file mode 100644 index 00000000..48329adc --- /dev/null +++ b/apis/batch/v1/zz_generated_job_controller.go @@ -0,0 +1,253 @@ +package v1 + +import ( + "context" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/api/batch/v1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" +) + +var ( + JobGroupVersionKind = schema.GroupVersionKind{ + Version: Version, + Group: GroupName, + Kind: "Job", + } + JobResource = metav1.APIResource{ + Name: "jobs", + SingularName: "job", + Namespaced: true, + + Kind: JobGroupVersionKind.Kind, + } +) + +type JobList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []v1.Job +} + +type JobHandlerFunc func(key string, obj *v1.Job) error + +type JobLister interface { + List(namespace string, selector labels.Selector) (ret []*v1.Job, err error) + Get(namespace, name string) (*v1.Job, error) +} + +type JobController interface { + Informer() cache.SharedIndexInformer + Lister() JobLister + AddHandler(name string, handler JobHandlerFunc) + AddClusterScopedHandler(name, clusterName string, handler JobHandlerFunc) + Enqueue(namespace, name string) + Sync(ctx context.Context) error + Start(ctx context.Context, threadiness int) error +} + +type JobInterface interface { + ObjectClient() *clientbase.ObjectClient + Create(*v1.Job) (*v1.Job, error) + GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.Job, error) + Get(name string, opts metav1.GetOptions) (*v1.Job, error) + Update(*v1.Job) (*v1.Job, error) + Delete(name string, options *metav1.DeleteOptions) error + DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error + List(opts metav1.ListOptions) (*JobList, error) + 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) +} + +type jobLister struct { + controller *jobController +} + +func (l *jobLister) List(namespace string, selector labels.Selector) (ret []*v1.Job, err error) { + err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { + ret = append(ret, obj.(*v1.Job)) + }) + return +} + +func (l *jobLister) Get(namespace, name string) (*v1.Job, error) { + var key string + if namespace != "" { + key = namespace + "/" + name + } else { + key = name + } + obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(schema.GroupResource{ + Group: JobGroupVersionKind.Group, + Resource: "job", + }, name) + } + return obj.(*v1.Job), nil +} + +type jobController struct { + controller.GenericController +} + +func (c *jobController) Lister() JobLister { + return &jobLister{ + controller: c, + } +} + +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 { + return handler(key, 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 { + return handler(key, nil) + } + + if !controller.ObjectInCluster(cluster, obj) { + return nil + } + + return handler(key, obj.(*v1.Job)) + }) +} + +type jobFactory struct { +} + +func (c jobFactory) Object() runtime.Object { + return &v1.Job{} +} + +func (c jobFactory) List() runtime.Object { + return &JobList{} +} + +func (s *jobClient) Controller() JobController { + s.client.Lock() + defer s.client.Unlock() + + c, ok := s.client.jobControllers[s.ns] + if ok { + return c + } + + genericController := controller.NewGenericController(JobGroupVersionKind.Kind+"Controller", + s.objectClient) + + c = &jobController{ + GenericController: genericController, + } + + s.client.jobControllers[s.ns] = c + s.client.starters = append(s.client.starters, c) + + return c +} + +type jobClient struct { + client *Client + ns string + objectClient *clientbase.ObjectClient + controller JobController +} + +func (s *jobClient) ObjectClient() *clientbase.ObjectClient { + return s.objectClient +} + +func (s *jobClient) Create(o *v1.Job) (*v1.Job, error) { + obj, err := s.objectClient.Create(o) + return obj.(*v1.Job), err +} + +func (s *jobClient) Get(name string, opts metav1.GetOptions) (*v1.Job, error) { + obj, err := s.objectClient.Get(name, opts) + return obj.(*v1.Job), err +} + +func (s *jobClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.Job, error) { + obj, err := s.objectClient.GetNamespaced(namespace, name, opts) + return obj.(*v1.Job), err +} + +func (s *jobClient) Update(o *v1.Job) (*v1.Job, error) { + obj, err := s.objectClient.Update(o.Name, o) + return obj.(*v1.Job), err +} + +func (s *jobClient) Delete(name string, options *metav1.DeleteOptions) error { + return s.objectClient.Delete(name, options) +} + +func (s *jobClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { + return s.objectClient.DeleteNamespaced(namespace, name, options) +} + +func (s *jobClient) List(opts metav1.ListOptions) (*JobList, error) { + obj, err := s.objectClient.List(opts) + return obj.(*JobList), err +} + +func (s *jobClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return s.objectClient.Watch(opts) +} + +// Patch applies the patch and returns the patched deployment. +func (s *jobClient) Patch(o *v1.Job, data []byte, subresources ...string) (*v1.Job, error) { + obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) + return obj.(*v1.Job), err +} + +func (s *jobClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { + return s.objectClient.DeleteCollection(deleteOpts, listOpts) +} + +func (s *jobClient) AddHandler(name string, sync JobHandlerFunc) { + s.Controller().AddHandler(name, sync) +} + +func (s *jobClient) AddLifecycle(name string, lifecycle JobLifecycle) { + sync := NewJobLifecycleAdapter(name, false, s, lifecycle) + s.AddHandler(name, sync) +} + +func (s *jobClient) AddClusterScopedHandler(name, clusterName string, sync JobHandlerFunc) { + s.Controller().AddClusterScopedHandler(name, clusterName, sync) +} + +func (s *jobClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle JobLifecycle) { + sync := NewJobLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) + s.AddClusterScopedHandler(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 new file mode 100644 index 00000000..5cd3ae82 --- /dev/null +++ b/apis/batch/v1/zz_generated_job_lifecycle_adapter.go @@ -0,0 +1,52 @@ +package v1 + +import ( + "github.com/rancher/norman/lifecycle" + "k8s.io/api/batch/v1" + "k8s.io/apimachinery/pkg/runtime" +) + +type JobLifecycle interface { + Create(obj *v1.Job) (*v1.Job, error) + Remove(obj *v1.Job) (*v1.Job, error) + Updated(obj *v1.Job) (*v1.Job, error) +} + +type jobLifecycleAdapter struct { + lifecycle JobLifecycle +} + +func (w *jobLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Create(obj.(*v1.Job)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *jobLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Remove(obj.(*v1.Job)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *jobLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Updated(obj.(*v1.Job)) + if o == nil { + return nil, err + } + return o, err +} + +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 syncFn(key, obj) + } +} diff --git a/apis/batch/v1/zz_generated_k8s_client.go b/apis/batch/v1/zz_generated_k8s_client.go new file mode 100644 index 00000000..636c9bfd --- /dev/null +++ b/apis/batch/v1/zz_generated_k8s_client.go @@ -0,0 +1,69 @@ +package v1 + +import ( + "context" + "sync" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" +) + +type Interface interface { + RESTClient() rest.Interface + controller.Starter + + JobsGetter +} + +type Client struct { + sync.Mutex + restClient rest.Interface + starters []controller.Starter + + jobControllers map[string]JobController +} + +func NewForConfig(config rest.Config) (Interface, error) { + if config.NegotiatedSerializer == nil { + configConfig := dynamic.ContentConfig() + config.NegotiatedSerializer = configConfig.NegotiatedSerializer + } + + restClient, err := rest.UnversionedRESTClientFor(&config) + if err != nil { + return nil, err + } + + return &Client{ + restClient: restClient, + + jobControllers: map[string]JobController{}, + }, nil +} + +func (c *Client) RESTClient() rest.Interface { + return c.restClient +} + +func (c *Client) Sync(ctx context.Context) error { + return controller.Sync(ctx, c.starters...) +} + +func (c *Client) Start(ctx context.Context, threadiness int) error { + return controller.Start(ctx, threadiness, c.starters...) +} + +type JobsGetter interface { + Jobs(namespace string) JobInterface +} + +func (c *Client) Jobs(namespace string) JobInterface { + objectClient := clientbase.NewObjectClient(namespace, c.restClient, &JobResource, JobGroupVersionKind, jobFactory{}) + return &jobClient{ + ns: namespace, + client: c, + objectClient: objectClient, + } +} diff --git a/apis/batch/v1/zz_generated_scheme.go b/apis/batch/v1/zz_generated_scheme.go new file mode 100644 index 00000000..e740c6d5 --- /dev/null +++ b/apis/batch/v1/zz_generated_scheme.go @@ -0,0 +1,39 @@ +package v1 + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +const ( + GroupName = "batch" + Version = "v1" +) + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: Version} + +// Kind takes an unqualified kind and returns a Group qualified GroupKind +func Kind(kind string) schema.GroupKind { + return SchemeGroupVersion.WithKind(kind).GroupKind() +} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + AddToScheme = SchemeBuilder.AddToScheme +) + +// Adds the list of known types to api.Scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + // TODO this gets cleaned up when the types are fixed + scheme.AddKnownTypes(SchemeGroupVersion, + + &JobList{}, + ) + return nil +} diff --git a/apis/batch/v1beta1/zz_generated_cron_job_controller.go b/apis/batch/v1beta1/zz_generated_cron_job_controller.go new file mode 100644 index 00000000..2d1ad5a0 --- /dev/null +++ b/apis/batch/v1beta1/zz_generated_cron_job_controller.go @@ -0,0 +1,253 @@ +package v1beta1 + +import ( + "context" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/api/batch/v1beta1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" +) + +var ( + CronJobGroupVersionKind = schema.GroupVersionKind{ + Version: Version, + Group: GroupName, + Kind: "CronJob", + } + CronJobResource = metav1.APIResource{ + Name: "cronjobs", + SingularName: "cronjob", + Namespaced: true, + + Kind: CronJobGroupVersionKind.Kind, + } +) + +type CronJobList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []v1beta1.CronJob +} + +type CronJobHandlerFunc func(key string, obj *v1beta1.CronJob) error + +type CronJobLister interface { + List(namespace string, selector labels.Selector) (ret []*v1beta1.CronJob, err error) + Get(namespace, name string) (*v1beta1.CronJob, error) +} + +type CronJobController interface { + Informer() cache.SharedIndexInformer + Lister() CronJobLister + AddHandler(name string, handler CronJobHandlerFunc) + AddClusterScopedHandler(name, clusterName string, handler CronJobHandlerFunc) + Enqueue(namespace, name string) + Sync(ctx context.Context) error + Start(ctx context.Context, threadiness int) error +} + +type CronJobInterface interface { + ObjectClient() *clientbase.ObjectClient + Create(*v1beta1.CronJob) (*v1beta1.CronJob, error) + GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1beta1.CronJob, error) + Get(name string, opts metav1.GetOptions) (*v1beta1.CronJob, error) + Update(*v1beta1.CronJob) (*v1beta1.CronJob, error) + Delete(name string, options *metav1.DeleteOptions) error + DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error + List(opts metav1.ListOptions) (*CronJobList, error) + 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) +} + +type cronJobLister struct { + controller *cronJobController +} + +func (l *cronJobLister) List(namespace string, selector labels.Selector) (ret []*v1beta1.CronJob, err error) { + err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { + ret = append(ret, obj.(*v1beta1.CronJob)) + }) + return +} + +func (l *cronJobLister) Get(namespace, name string) (*v1beta1.CronJob, error) { + var key string + if namespace != "" { + key = namespace + "/" + name + } else { + key = name + } + obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(schema.GroupResource{ + Group: CronJobGroupVersionKind.Group, + Resource: "cronJob", + }, name) + } + return obj.(*v1beta1.CronJob), nil +} + +type cronJobController struct { + controller.GenericController +} + +func (c *cronJobController) Lister() CronJobLister { + return &cronJobLister{ + controller: c, + } +} + +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 { + return handler(key, 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 { + return handler(key, nil) + } + + if !controller.ObjectInCluster(cluster, obj) { + return nil + } + + return handler(key, obj.(*v1beta1.CronJob)) + }) +} + +type cronJobFactory struct { +} + +func (c cronJobFactory) Object() runtime.Object { + return &v1beta1.CronJob{} +} + +func (c cronJobFactory) List() runtime.Object { + return &CronJobList{} +} + +func (s *cronJobClient) Controller() CronJobController { + s.client.Lock() + defer s.client.Unlock() + + c, ok := s.client.cronJobControllers[s.ns] + if ok { + return c + } + + genericController := controller.NewGenericController(CronJobGroupVersionKind.Kind+"Controller", + s.objectClient) + + c = &cronJobController{ + GenericController: genericController, + } + + s.client.cronJobControllers[s.ns] = c + s.client.starters = append(s.client.starters, c) + + return c +} + +type cronJobClient struct { + client *Client + ns string + objectClient *clientbase.ObjectClient + controller CronJobController +} + +func (s *cronJobClient) ObjectClient() *clientbase.ObjectClient { + return s.objectClient +} + +func (s *cronJobClient) Create(o *v1beta1.CronJob) (*v1beta1.CronJob, error) { + obj, err := s.objectClient.Create(o) + return obj.(*v1beta1.CronJob), err +} + +func (s *cronJobClient) Get(name string, opts metav1.GetOptions) (*v1beta1.CronJob, error) { + obj, err := s.objectClient.Get(name, opts) + return obj.(*v1beta1.CronJob), err +} + +func (s *cronJobClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1beta1.CronJob, error) { + obj, err := s.objectClient.GetNamespaced(namespace, name, opts) + return obj.(*v1beta1.CronJob), err +} + +func (s *cronJobClient) Update(o *v1beta1.CronJob) (*v1beta1.CronJob, error) { + obj, err := s.objectClient.Update(o.Name, o) + return obj.(*v1beta1.CronJob), err +} + +func (s *cronJobClient) Delete(name string, options *metav1.DeleteOptions) error { + return s.objectClient.Delete(name, options) +} + +func (s *cronJobClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { + return s.objectClient.DeleteNamespaced(namespace, name, options) +} + +func (s *cronJobClient) List(opts metav1.ListOptions) (*CronJobList, error) { + obj, err := s.objectClient.List(opts) + return obj.(*CronJobList), err +} + +func (s *cronJobClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return s.objectClient.Watch(opts) +} + +// Patch applies the patch and returns the patched deployment. +func (s *cronJobClient) Patch(o *v1beta1.CronJob, data []byte, subresources ...string) (*v1beta1.CronJob, error) { + obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) + return obj.(*v1beta1.CronJob), err +} + +func (s *cronJobClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { + return s.objectClient.DeleteCollection(deleteOpts, listOpts) +} + +func (s *cronJobClient) AddHandler(name string, sync CronJobHandlerFunc) { + s.Controller().AddHandler(name, sync) +} + +func (s *cronJobClient) AddLifecycle(name string, lifecycle CronJobLifecycle) { + sync := NewCronJobLifecycleAdapter(name, false, s, lifecycle) + s.AddHandler(name, sync) +} + +func (s *cronJobClient) AddClusterScopedHandler(name, clusterName string, sync CronJobHandlerFunc) { + s.Controller().AddClusterScopedHandler(name, clusterName, sync) +} + +func (s *cronJobClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle CronJobLifecycle) { + sync := NewCronJobLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) + s.AddClusterScopedHandler(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 new file mode 100644 index 00000000..6040ff84 --- /dev/null +++ b/apis/batch/v1beta1/zz_generated_cron_job_lifecycle_adapter.go @@ -0,0 +1,52 @@ +package v1beta1 + +import ( + "github.com/rancher/norman/lifecycle" + "k8s.io/api/batch/v1beta1" + "k8s.io/apimachinery/pkg/runtime" +) + +type CronJobLifecycle interface { + Create(obj *v1beta1.CronJob) (*v1beta1.CronJob, error) + Remove(obj *v1beta1.CronJob) (*v1beta1.CronJob, error) + Updated(obj *v1beta1.CronJob) (*v1beta1.CronJob, error) +} + +type cronJobLifecycleAdapter struct { + lifecycle CronJobLifecycle +} + +func (w *cronJobLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Create(obj.(*v1beta1.CronJob)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *cronJobLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Remove(obj.(*v1beta1.CronJob)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *cronJobLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Updated(obj.(*v1beta1.CronJob)) + if o == nil { + return nil, err + } + return o, err +} + +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 syncFn(key, obj) + } +} diff --git a/apis/batch/v1beta1/zz_generated_deepcopy.go b/apis/batch/v1beta1/zz_generated_deepcopy.go new file mode 100644 index 00000000..a6c5ce75 --- /dev/null +++ b/apis/batch/v1beta1/zz_generated_deepcopy.go @@ -0,0 +1,60 @@ +package v1beta1 + +import ( + reflect "reflect" + + batch_v1beta1 "k8s.io/api/batch/v1beta1" + conversion "k8s.io/apimachinery/pkg/conversion" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +func init() { + SchemeBuilder.Register(RegisterDeepCopies) +} + +// RegisterDeepCopies adds deep-copy functions to the given scheme. Public +// to allow building arbitrary schemes. +// +// Deprecated: deepcopy registration will go away when static deepcopy is fully implemented. +func RegisterDeepCopies(scheme *runtime.Scheme) error { + return scheme.AddGeneratedDeepCopyFuncs( + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*CronJobList).DeepCopyInto(out.(*CronJobList)) + return nil + }, InType: reflect.TypeOf(&CronJobList{})}, + ) +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CronJobList) DeepCopyInto(out *CronJobList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]batch_v1beta1.CronJob, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CronJobList. +func (in *CronJobList) DeepCopy() *CronJobList { + if in == nil { + return nil + } + out := new(CronJobList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *CronJobList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} diff --git a/apis/batch/v1beta1/zz_generated_k8s_client.go b/apis/batch/v1beta1/zz_generated_k8s_client.go new file mode 100644 index 00000000..839c302c --- /dev/null +++ b/apis/batch/v1beta1/zz_generated_k8s_client.go @@ -0,0 +1,69 @@ +package v1beta1 + +import ( + "context" + "sync" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" +) + +type Interface interface { + RESTClient() rest.Interface + controller.Starter + + CronJobsGetter +} + +type Client struct { + sync.Mutex + restClient rest.Interface + starters []controller.Starter + + cronJobControllers map[string]CronJobController +} + +func NewForConfig(config rest.Config) (Interface, error) { + if config.NegotiatedSerializer == nil { + configConfig := dynamic.ContentConfig() + config.NegotiatedSerializer = configConfig.NegotiatedSerializer + } + + restClient, err := rest.UnversionedRESTClientFor(&config) + if err != nil { + return nil, err + } + + return &Client{ + restClient: restClient, + + cronJobControllers: map[string]CronJobController{}, + }, nil +} + +func (c *Client) RESTClient() rest.Interface { + return c.restClient +} + +func (c *Client) Sync(ctx context.Context) error { + return controller.Sync(ctx, c.starters...) +} + +func (c *Client) Start(ctx context.Context, threadiness int) error { + return controller.Start(ctx, threadiness, c.starters...) +} + +type CronJobsGetter interface { + CronJobs(namespace string) CronJobInterface +} + +func (c *Client) CronJobs(namespace string) CronJobInterface { + objectClient := clientbase.NewObjectClient(namespace, c.restClient, &CronJobResource, CronJobGroupVersionKind, cronJobFactory{}) + return &cronJobClient{ + ns: namespace, + client: c, + objectClient: objectClient, + } +} diff --git a/apis/batch/v1beta1/zz_generated_scheme.go b/apis/batch/v1beta1/zz_generated_scheme.go new file mode 100644 index 00000000..fc195822 --- /dev/null +++ b/apis/batch/v1beta1/zz_generated_scheme.go @@ -0,0 +1,39 @@ +package v1beta1 + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +const ( + GroupName = "batch" + Version = "v1beta1" +) + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: Version} + +// Kind takes an unqualified kind and returns a Group qualified GroupKind +func Kind(kind string) schema.GroupKind { + return SchemeGroupVersion.WithKind(kind).GroupKind() +} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + AddToScheme = SchemeBuilder.AddToScheme +) + +// Adds the list of known types to api.Scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + // TODO this gets cleaned up when the types are fixed + scheme.AddKnownTypes(SchemeGroupVersion, + + &CronJobList{}, + ) + return nil +} diff --git a/apis/core/v1/zz_generated_deepcopy.go b/apis/core/v1/zz_generated_deepcopy.go index 29c74631..c60ebfbb 100644 --- a/apis/core/v1/zz_generated_deepcopy.go +++ b/apis/core/v1/zz_generated_deepcopy.go @@ -46,6 +46,10 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*PodList).DeepCopyInto(out.(*PodList)) return nil }, InType: reflect.TypeOf(&PodList{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ReplicationControllerList).DeepCopyInto(out.(*ReplicationControllerList)) + return nil + }, InType: reflect.TypeOf(&ReplicationControllerList{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*SecretList).DeepCopyInto(out.(*SecretList)) return nil @@ -299,6 +303,40 @@ func (in *PodList) DeepCopyObject() runtime.Object { } } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ReplicationControllerList) DeepCopyInto(out *ReplicationControllerList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]core_v1.ReplicationController, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationControllerList. +func (in *ReplicationControllerList) DeepCopy() *ReplicationControllerList { + if in == nil { + return nil + } + out := new(ReplicationControllerList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ReplicationControllerList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *SecretList) DeepCopyInto(out *SecretList) { *out = *in diff --git a/apis/core/v1/zz_generated_k8s_client.go b/apis/core/v1/zz_generated_k8s_client.go index bb9c86df..d74e2284 100644 --- a/apis/core/v1/zz_generated_k8s_client.go +++ b/apis/core/v1/zz_generated_k8s_client.go @@ -24,6 +24,7 @@ type Interface interface { SecretsGetter ConfigMapsGetter ServiceAccountsGetter + ReplicationControllersGetter } type Client struct { @@ -31,16 +32,17 @@ type Client struct { restClient rest.Interface starters []controller.Starter - nodeControllers map[string]NodeController - componentStatusControllers map[string]ComponentStatusController - namespaceControllers map[string]NamespaceController - eventControllers map[string]EventController - endpointsControllers map[string]EndpointsController - podControllers map[string]PodController - serviceControllers map[string]ServiceController - secretControllers map[string]SecretController - configMapControllers map[string]ConfigMapController - serviceAccountControllers map[string]ServiceAccountController + nodeControllers map[string]NodeController + componentStatusControllers map[string]ComponentStatusController + namespaceControllers map[string]NamespaceController + eventControllers map[string]EventController + endpointsControllers map[string]EndpointsController + podControllers map[string]PodController + serviceControllers map[string]ServiceController + secretControllers map[string]SecretController + configMapControllers map[string]ConfigMapController + serviceAccountControllers map[string]ServiceAccountController + replicationControllerControllers map[string]ReplicationControllerController } func NewForConfig(config rest.Config) (Interface, error) { @@ -57,16 +59,17 @@ func NewForConfig(config rest.Config) (Interface, error) { return &Client{ restClient: restClient, - nodeControllers: map[string]NodeController{}, - componentStatusControllers: map[string]ComponentStatusController{}, - namespaceControllers: map[string]NamespaceController{}, - eventControllers: map[string]EventController{}, - endpointsControllers: map[string]EndpointsController{}, - podControllers: map[string]PodController{}, - serviceControllers: map[string]ServiceController{}, - secretControllers: map[string]SecretController{}, - configMapControllers: map[string]ConfigMapController{}, - serviceAccountControllers: map[string]ServiceAccountController{}, + nodeControllers: map[string]NodeController{}, + componentStatusControllers: map[string]ComponentStatusController{}, + namespaceControllers: map[string]NamespaceController{}, + eventControllers: map[string]EventController{}, + endpointsControllers: map[string]EndpointsController{}, + podControllers: map[string]PodController{}, + serviceControllers: map[string]ServiceController{}, + secretControllers: map[string]SecretController{}, + configMapControllers: map[string]ConfigMapController{}, + serviceAccountControllers: map[string]ServiceAccountController{}, + replicationControllerControllers: map[string]ReplicationControllerController{}, }, nil } @@ -211,3 +214,16 @@ func (c *Client) ServiceAccounts(namespace string) ServiceAccountInterface { objectClient: objectClient, } } + +type ReplicationControllersGetter interface { + ReplicationControllers(namespace string) ReplicationControllerInterface +} + +func (c *Client) ReplicationControllers(namespace string) ReplicationControllerInterface { + objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ReplicationControllerResource, ReplicationControllerGroupVersionKind, replicationControllerFactory{}) + return &replicationControllerClient{ + ns: namespace, + client: c, + objectClient: objectClient, + } +} diff --git a/apis/core/v1/zz_generated_replication_controller_controller.go b/apis/core/v1/zz_generated_replication_controller_controller.go new file mode 100644 index 00000000..e599a67e --- /dev/null +++ b/apis/core/v1/zz_generated_replication_controller_controller.go @@ -0,0 +1,253 @@ +package v1 + +import ( + "context" + + "github.com/rancher/norman/clientbase" + "github.com/rancher/norman/controller" + "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" +) + +var ( + ReplicationControllerGroupVersionKind = schema.GroupVersionKind{ + Version: Version, + Group: GroupName, + Kind: "ReplicationController", + } + ReplicationControllerResource = metav1.APIResource{ + Name: "replicationcontrollers", + SingularName: "replicationcontroller", + Namespaced: true, + + Kind: ReplicationControllerGroupVersionKind.Kind, + } +) + +type ReplicationControllerList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []v1.ReplicationController +} + +type ReplicationControllerHandlerFunc func(key string, obj *v1.ReplicationController) error + +type ReplicationControllerLister interface { + List(namespace string, selector labels.Selector) (ret []*v1.ReplicationController, err error) + Get(namespace, name string) (*v1.ReplicationController, error) +} + +type ReplicationControllerController interface { + Informer() cache.SharedIndexInformer + Lister() ReplicationControllerLister + AddHandler(name string, handler ReplicationControllerHandlerFunc) + AddClusterScopedHandler(name, clusterName string, handler ReplicationControllerHandlerFunc) + Enqueue(namespace, name string) + Sync(ctx context.Context) error + Start(ctx context.Context, threadiness int) error +} + +type ReplicationControllerInterface interface { + ObjectClient() *clientbase.ObjectClient + Create(*v1.ReplicationController) (*v1.ReplicationController, error) + GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.ReplicationController, error) + Get(name string, opts metav1.GetOptions) (*v1.ReplicationController, error) + Update(*v1.ReplicationController) (*v1.ReplicationController, error) + Delete(name string, options *metav1.DeleteOptions) error + DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error + List(opts metav1.ListOptions) (*ReplicationControllerList, error) + 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) +} + +type replicationControllerLister struct { + controller *replicationControllerController +} + +func (l *replicationControllerLister) List(namespace string, selector labels.Selector) (ret []*v1.ReplicationController, err error) { + err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { + ret = append(ret, obj.(*v1.ReplicationController)) + }) + return +} + +func (l *replicationControllerLister) Get(namespace, name string) (*v1.ReplicationController, error) { + var key string + if namespace != "" { + key = namespace + "/" + name + } else { + key = name + } + obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(schema.GroupResource{ + Group: ReplicationControllerGroupVersionKind.Group, + Resource: "replicationController", + }, name) + } + return obj.(*v1.ReplicationController), nil +} + +type replicationControllerController struct { + controller.GenericController +} + +func (c *replicationControllerController) Lister() ReplicationControllerLister { + return &replicationControllerLister{ + controller: c, + } +} + +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 { + return handler(key, 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 { + return handler(key, nil) + } + + if !controller.ObjectInCluster(cluster, obj) { + return nil + } + + return handler(key, obj.(*v1.ReplicationController)) + }) +} + +type replicationControllerFactory struct { +} + +func (c replicationControllerFactory) Object() runtime.Object { + return &v1.ReplicationController{} +} + +func (c replicationControllerFactory) List() runtime.Object { + return &ReplicationControllerList{} +} + +func (s *replicationControllerClient) Controller() ReplicationControllerController { + s.client.Lock() + defer s.client.Unlock() + + c, ok := s.client.replicationControllerControllers[s.ns] + if ok { + return c + } + + genericController := controller.NewGenericController(ReplicationControllerGroupVersionKind.Kind+"Controller", + s.objectClient) + + c = &replicationControllerController{ + GenericController: genericController, + } + + s.client.replicationControllerControllers[s.ns] = c + s.client.starters = append(s.client.starters, c) + + return c +} + +type replicationControllerClient struct { + client *Client + ns string + objectClient *clientbase.ObjectClient + controller ReplicationControllerController +} + +func (s *replicationControllerClient) ObjectClient() *clientbase.ObjectClient { + return s.objectClient +} + +func (s *replicationControllerClient) Create(o *v1.ReplicationController) (*v1.ReplicationController, error) { + obj, err := s.objectClient.Create(o) + return obj.(*v1.ReplicationController), err +} + +func (s *replicationControllerClient) Get(name string, opts metav1.GetOptions) (*v1.ReplicationController, error) { + obj, err := s.objectClient.Get(name, opts) + return obj.(*v1.ReplicationController), err +} + +func (s *replicationControllerClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*v1.ReplicationController, error) { + obj, err := s.objectClient.GetNamespaced(namespace, name, opts) + return obj.(*v1.ReplicationController), err +} + +func (s *replicationControllerClient) Update(o *v1.ReplicationController) (*v1.ReplicationController, error) { + obj, err := s.objectClient.Update(o.Name, o) + return obj.(*v1.ReplicationController), err +} + +func (s *replicationControllerClient) Delete(name string, options *metav1.DeleteOptions) error { + return s.objectClient.Delete(name, options) +} + +func (s *replicationControllerClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { + return s.objectClient.DeleteNamespaced(namespace, name, options) +} + +func (s *replicationControllerClient) List(opts metav1.ListOptions) (*ReplicationControllerList, error) { + obj, err := s.objectClient.List(opts) + return obj.(*ReplicationControllerList), err +} + +func (s *replicationControllerClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return s.objectClient.Watch(opts) +} + +// Patch applies the patch and returns the patched deployment. +func (s *replicationControllerClient) Patch(o *v1.ReplicationController, data []byte, subresources ...string) (*v1.ReplicationController, error) { + obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) + return obj.(*v1.ReplicationController), err +} + +func (s *replicationControllerClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { + return s.objectClient.DeleteCollection(deleteOpts, listOpts) +} + +func (s *replicationControllerClient) AddHandler(name string, sync ReplicationControllerHandlerFunc) { + s.Controller().AddHandler(name, sync) +} + +func (s *replicationControllerClient) AddLifecycle(name string, lifecycle ReplicationControllerLifecycle) { + sync := NewReplicationControllerLifecycleAdapter(name, false, s, lifecycle) + s.AddHandler(name, sync) +} + +func (s *replicationControllerClient) AddClusterScopedHandler(name, clusterName string, sync ReplicationControllerHandlerFunc) { + s.Controller().AddClusterScopedHandler(name, clusterName, sync) +} + +func (s *replicationControllerClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ReplicationControllerLifecycle) { + sync := NewReplicationControllerLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) + s.AddClusterScopedHandler(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 new file mode 100644 index 00000000..c3083a04 --- /dev/null +++ b/apis/core/v1/zz_generated_replication_controller_lifecycle_adapter.go @@ -0,0 +1,52 @@ +package v1 + +import ( + "github.com/rancher/norman/lifecycle" + "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" +) + +type ReplicationControllerLifecycle interface { + Create(obj *v1.ReplicationController) (*v1.ReplicationController, error) + Remove(obj *v1.ReplicationController) (*v1.ReplicationController, error) + Updated(obj *v1.ReplicationController) (*v1.ReplicationController, error) +} + +type replicationControllerLifecycleAdapter struct { + lifecycle ReplicationControllerLifecycle +} + +func (w *replicationControllerLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Create(obj.(*v1.ReplicationController)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *replicationControllerLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Remove(obj.(*v1.ReplicationController)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *replicationControllerLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Updated(obj.(*v1.ReplicationController)) + if o == nil { + return nil, err + } + return o, err +} + +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 syncFn(key, obj) + } +} diff --git a/apis/core/v1/zz_generated_scheme.go b/apis/core/v1/zz_generated_scheme.go index b6bcd707..7a17e7f5 100644 --- a/apis/core/v1/zz_generated_scheme.go +++ b/apis/core/v1/zz_generated_scheme.go @@ -43,6 +43,7 @@ func addKnownTypes(scheme *runtime.Scheme) error { &SecretList{}, &ConfigMapList{}, &ServiceAccountList{}, + &ReplicationControllerList{}, ) return nil }