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

Updated generated code

Browse Source
This commit is contained in:
Darren Shepherd
2017-12-05 09:32:54 -07:00
parent 5579f880d0
commit 00384d0e99
282 changed files with 1674 additions and 1280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
apis/cluster.cattle.io/v1/zz_generated_cluster_controller.go
View File

@@ -1,187 +0,0 @@
package v1
import (
"context"
"github.com/rancher/norman/clientbase"
"github.com/rancher/norman/controller"
"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 (
ClusterGroupVersionKind = schema.GroupVersionKind{
Version: "v1",
Group: "cluster.cattle.io",
Kind: "Cluster",
}
ClusterResource = metav1.APIResource{
Name: "clusters",
SingularName: "cluster",
Namespaced: false,
Kind: ClusterGroupVersionKind.Kind,
}
)
type ClusterList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []Cluster
}
type ClusterHandlerFunc func(key string, obj *Cluster) error
type ClusterLister interface {
List(namespace string, selector labels.Selector) (ret []*Cluster, err error)
Get(namespace, name string) (*Cluster, error)
}
type ClusterController interface {
Informer() cache.SharedIndexInformer
Lister() ClusterLister
AddHandler(handler ClusterHandlerFunc)
Enqueue(namespace, name string)
Sync(ctx context.Context) error
Start(ctx context.Context, threadiness int) error
}
type ClusterInterface interface {
ObjectClient() *clientbase.ObjectClient
Create(*Cluster) (*Cluster, error)
Get(name string, opts metav1.GetOptions) (*Cluster, error)
Update(*Cluster) (*Cluster, error)
Delete(name string, options *metav1.DeleteOptions) error
List(opts metav1.ListOptions) (*ClusterList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
Controller() ClusterController
}
type clusterLister struct {
controller *clusterController
}
func (l *clusterLister) List(namespace string, selector labels.Selector) (ret []*Cluster, err error) {
err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
ret = append(ret, obj.(*Cluster))
})
return
}
func (l *clusterLister) Get(namespace, name string) (*Cluster, error) {
obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(schema.GroupResource{
Group: ClusterGroupVersionKind.Group,
Resource: "cluster",
}, name)
}
return obj.(*Cluster), nil
}
type clusterController struct {
controller.GenericController
}
func (c *clusterController) Lister() ClusterLister {
return &clusterLister{
controller: c,
}
}
func (c *clusterController) AddHandler(handler ClusterHandlerFunc) {
c.GenericController.AddHandler(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.(*Cluster))
})
}
type clusterFactory struct {
}
func (c clusterFactory) Object() runtime.Object {
return &Cluster{}
}
func (c clusterFactory) List() runtime.Object {
return &ClusterList{}
}
func (s *clusterClient) Controller() ClusterController {
s.client.Lock()
defer s.client.Unlock()
c, ok := s.client.clusterControllers[s.ns]
if ok {
return c
}
genericController := controller.NewGenericController(ClusterGroupVersionKind.Kind+"Controller",
s.objectClient)
c = &clusterController{
GenericController: genericController,
}
s.client.clusterControllers[s.ns] = c
s.client.starters = append(s.client.starters, c)
return c
}
type clusterClient struct {
client *Client
ns string
objectClient *clientbase.ObjectClient
controller ClusterController
}
func (s *clusterClient) ObjectClient() *clientbase.ObjectClient {
return s.objectClient
}
func (s *clusterClient) Create(o *Cluster) (*Cluster, error) {
obj, err := s.objectClient.Create(o)
return obj.(*Cluster), err
}
func (s *clusterClient) Get(name string, opts metav1.GetOptions) (*Cluster, error) {
obj, err := s.objectClient.Get(name, opts)
return obj.(*Cluster), err
}
func (s *clusterClient) Update(o *Cluster) (*Cluster, error) {
obj, err := s.objectClient.Update(o.Name, o)
return obj.(*Cluster), err
}
func (s *clusterClient) Delete(name string, options *metav1.DeleteOptions) error {
return s.objectClient.Delete(name, options)
}
func (s *clusterClient) List(opts metav1.ListOptions) (*ClusterList, error) {
obj, err := s.objectClient.List(opts)
return obj.(*ClusterList), err
}
func (s *clusterClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return s.objectClient.Watch(opts)
}
func (s *clusterClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}

187
apis/cluster.cattle.io/v1/zz_generated_cluster_node_controller.go
View File

@@ -1,187 +0,0 @@
package v1
import (
"context"
"github.com/rancher/norman/clientbase"
"github.com/rancher/norman/controller"
"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 (
ClusterNodeGroupVersionKind = schema.GroupVersionKind{
Version: "v1",
Group: "cluster.cattle.io",
Kind: "ClusterNode",
}
ClusterNodeResource = metav1.APIResource{
Name: "clusternodes",
SingularName: "clusternode",
Namespaced: false,
Kind: ClusterNodeGroupVersionKind.Kind,
}
)
type ClusterNodeList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []ClusterNode
}
type ClusterNodeHandlerFunc func(key string, obj *ClusterNode) error
type ClusterNodeLister interface {
List(namespace string, selector labels.Selector) (ret []*ClusterNode, err error)
Get(namespace, name string) (*ClusterNode, error)
}
type ClusterNodeController interface {
Informer() cache.SharedIndexInformer
Lister() ClusterNodeLister
AddHandler(handler ClusterNodeHandlerFunc)
Enqueue(namespace, name string)
Sync(ctx context.Context) error
Start(ctx context.Context, threadiness int) error
}
type ClusterNodeInterface interface {
ObjectClient() *clientbase.ObjectClient
Create(*ClusterNode) (*ClusterNode, error)
Get(name string, opts metav1.GetOptions) (*ClusterNode, error)
Update(*ClusterNode) (*ClusterNode, error)
Delete(name string, options *metav1.DeleteOptions) error
List(opts metav1.ListOptions) (*ClusterNodeList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
Controller() ClusterNodeController
}
type clusterNodeLister struct {
controller *clusterNodeController
}
func (l *clusterNodeLister) List(namespace string, selector labels.Selector) (ret []*ClusterNode, err error) {
err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
ret = append(ret, obj.(*ClusterNode))
})
return
}
func (l *clusterNodeLister) Get(namespace, name string) (*ClusterNode, error) {
obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(schema.GroupResource{
Group: ClusterNodeGroupVersionKind.Group,
Resource: "clusterNode",
}, name)
}
return obj.(*ClusterNode), nil
}
type clusterNodeController struct {
controller.GenericController
}
func (c *clusterNodeController) Lister() ClusterNodeLister {
return &clusterNodeLister{
controller: c,
}
}
func (c *clusterNodeController) AddHandler(handler ClusterNodeHandlerFunc) {
c.GenericController.AddHandler(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.(*ClusterNode))
})
}
type clusterNodeFactory struct {
}
func (c clusterNodeFactory) Object() runtime.Object {
return &ClusterNode{}
}
func (c clusterNodeFactory) List() runtime.Object {
return &ClusterNodeList{}
}
func (s *clusterNodeClient) Controller() ClusterNodeController {
s.client.Lock()
defer s.client.Unlock()
c, ok := s.client.clusterNodeControllers[s.ns]
if ok {
return c
}
genericController := controller.NewGenericController(ClusterNodeGroupVersionKind.Kind+"Controller",
s.objectClient)
c = &clusterNodeController{
GenericController: genericController,
}
s.client.clusterNodeControllers[s.ns] = c
s.client.starters = append(s.client.starters, c)
return c
}
type clusterNodeClient struct {
client *Client
ns string
objectClient *clientbase.ObjectClient
controller ClusterNodeController
}
func (s *clusterNodeClient) ObjectClient() *clientbase.ObjectClient {
return s.objectClient
}
func (s *clusterNodeClient) Create(o *ClusterNode) (*ClusterNode, error) {
obj, err := s.objectClient.Create(o)
return obj.(*ClusterNode), err
}
func (s *clusterNodeClient) Get(name string, opts metav1.GetOptions) (*ClusterNode, error) {
obj, err := s.objectClient.Get(name, opts)
return obj.(*ClusterNode), err
}
func (s *clusterNodeClient) Update(o *ClusterNode) (*ClusterNode, error) {
obj, err := s.objectClient.Update(o.Name, o)
return obj.(*ClusterNode), err
}
func (s *clusterNodeClient) Delete(name string, options *metav1.DeleteOptions) error {
return s.objectClient.Delete(name, options)
}
func (s *clusterNodeClient) List(opts metav1.ListOptions) (*ClusterNodeList, error) {
obj, err := s.objectClient.List(opts)
return obj.(*ClusterNodeList), err
}
func (s *clusterNodeClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return s.objectClient.Watch(opts)
}
func (s *clusterNodeClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}

1047
apis/cluster.cattle.io/v1/zz_generated_deepcopy.go
View File

File diff suppressed because it is too large Load Diff

133
apis/cluster.cattle.io/v1/zz_generated_k8s_client.go
View File

@@ -1,133 +0,0 @@
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
ClustersGetter
ClusterNodesGetter
MachinesGetter
MachineDriversGetter
MachineTemplatesGetter
}
type Client struct {
sync.Mutex
restClient rest.Interface
starters []controller.Starter
clusterControllers map[string]ClusterController
clusterNodeControllers map[string]ClusterNodeController
machineControllers map[string]MachineController
machineDriverControllers map[string]MachineDriverController
machineTemplateControllers map[string]MachineTemplateController
}
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,
clusterControllers: map[string]ClusterController{},
clusterNodeControllers: map[string]ClusterNodeController{},
machineControllers: map[string]MachineController{},
machineDriverControllers: map[string]MachineDriverController{},
machineTemplateControllers: map[string]MachineTemplateController{},
}, 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 ClustersGetter interface {
Clusters(namespace string) ClusterInterface
}
func (c *Client) Clusters(namespace string) ClusterInterface {
objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ClusterResource, ClusterGroupVersionKind, clusterFactory{})
return &clusterClient{
ns: namespace,
client: c,
objectClient: objectClient,
}
}
type ClusterNodesGetter interface {
ClusterNodes(namespace string) ClusterNodeInterface
}
func (c *Client) ClusterNodes(namespace string) ClusterNodeInterface {
objectClient := clientbase.NewObjectClient(namespace, c.restClient, &ClusterNodeResource, ClusterNodeGroupVersionKind, clusterNodeFactory{})
return &clusterNodeClient{
ns: namespace,
client: c,
objectClient: objectClient,
}
}
type MachinesGetter interface {
Machines(namespace string) MachineInterface
}
func (c *Client) Machines(namespace string) MachineInterface {
objectClient := clientbase.NewObjectClient(namespace, c.restClient, &MachineResource, MachineGroupVersionKind, machineFactory{})
return &machineClient{
ns: namespace,
client: c,
objectClient: objectClient,
}
}
type MachineDriversGetter interface {
MachineDrivers(namespace string) MachineDriverInterface
}
func (c *Client) MachineDrivers(namespace string) MachineDriverInterface {
objectClient := clientbase.NewObjectClient(namespace, c.restClient, &MachineDriverResource, MachineDriverGroupVersionKind, machineDriverFactory{})
return &machineDriverClient{
ns: namespace,
client: c,
objectClient: objectClient,
}
}
type MachineTemplatesGetter interface {
MachineTemplates(namespace string) MachineTemplateInterface
}
func (c *Client) MachineTemplates(namespace string) MachineTemplateInterface {
objectClient := clientbase.NewObjectClient(namespace, c.restClient, &MachineTemplateResource, MachineTemplateGroupVersionKind, machineTemplateFactory{})
return &machineTemplateClient{
ns: namespace,
client: c,
objectClient: objectClient,
}
}

187
apis/cluster.cattle.io/v1/zz_generated_machine_controller.go
View File

@@ -1,187 +0,0 @@
package v1
import (
"context"
"github.com/rancher/norman/clientbase"
"github.com/rancher/norman/controller"
"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 (
MachineGroupVersionKind = schema.GroupVersionKind{
Version: "v1",
Group: "cluster.cattle.io",
Kind: "Machine",
}
MachineResource = metav1.APIResource{
Name: "machines",
SingularName: "machine",
Namespaced: false,
Kind: MachineGroupVersionKind.Kind,
}
)
type MachineList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []Machine
}
type MachineHandlerFunc func(key string, obj *Machine) error
type MachineLister interface {
List(namespace string, selector labels.Selector) (ret []*Machine, err error)
Get(namespace, name string) (*Machine, error)
}
type MachineController interface {
Informer() cache.SharedIndexInformer
Lister() MachineLister
AddHandler(handler MachineHandlerFunc)
Enqueue(namespace, name string)
Sync(ctx context.Context) error
Start(ctx context.Context, threadiness int) error
}
type MachineInterface interface {
ObjectClient() *clientbase.ObjectClient
Create(*Machine) (*Machine, error)
Get(name string, opts metav1.GetOptions) (*Machine, error)
Update(*Machine) (*Machine, error)
Delete(name string, options *metav1.DeleteOptions) error
List(opts metav1.ListOptions) (*MachineList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
Controller() MachineController
}
type machineLister struct {
controller *machineController
}
func (l *machineLister) List(namespace string, selector labels.Selector) (ret []*Machine, err error) {
err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
ret = append(ret, obj.(*Machine))
})
return
}
func (l *machineLister) Get(namespace, name string) (*Machine, error) {
obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(schema.GroupResource{
Group: MachineGroupVersionKind.Group,
Resource: "machine",
}, name)
}
return obj.(*Machine), nil
}
type machineController struct {
controller.GenericController
}
func (c *machineController) Lister() MachineLister {
return &machineLister{
controller: c,
}
}
func (c *machineController) AddHandler(handler MachineHandlerFunc) {
c.GenericController.AddHandler(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.(*Machine))
})
}
type machineFactory struct {
}
func (c machineFactory) Object() runtime.Object {
return &Machine{}
}
func (c machineFactory) List() runtime.Object {
return &MachineList{}
}
func (s *machineClient) Controller() MachineController {
s.client.Lock()
defer s.client.Unlock()
c, ok := s.client.machineControllers[s.ns]
if ok {
return c
}
genericController := controller.NewGenericController(MachineGroupVersionKind.Kind+"Controller",
s.objectClient)
c = &machineController{
GenericController: genericController,
}
s.client.machineControllers[s.ns] = c
s.client.starters = append(s.client.starters, c)
return c
}
type machineClient struct {
client *Client
ns string
objectClient *clientbase.ObjectClient
controller MachineController
}
func (s *machineClient) ObjectClient() *clientbase.ObjectClient {
return s.objectClient
}
func (s *machineClient) Create(o *Machine) (*Machine, error) {
obj, err := s.objectClient.Create(o)
return obj.(*Machine), err
}
func (s *machineClient) Get(name string, opts metav1.GetOptions) (*Machine, error) {
obj, err := s.objectClient.Get(name, opts)
return obj.(*Machine), err
}
func (s *machineClient) Update(o *Machine) (*Machine, error) {
obj, err := s.objectClient.Update(o.Name, o)
return obj.(*Machine), err
}
func (s *machineClient) Delete(name string, options *metav1.DeleteOptions) error {
return s.objectClient.Delete(name, options)
}
func (s *machineClient) List(opts metav1.ListOptions) (*MachineList, error) {
obj, err := s.objectClient.List(opts)
return obj.(*MachineList), err
}
func (s *machineClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return s.objectClient.Watch(opts)
}
func (s *machineClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}

187
apis/cluster.cattle.io/v1/zz_generated_machine_driver_controller.go
View File

@@ -1,187 +0,0 @@
package v1
import (
"context"
"github.com/rancher/norman/clientbase"
"github.com/rancher/norman/controller"
"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 (
MachineDriverGroupVersionKind = schema.GroupVersionKind{
Version: "v1",
Group: "cluster.cattle.io",
Kind: "MachineDriver",
}
MachineDriverResource = metav1.APIResource{
Name: "machinedrivers",
SingularName: "machinedriver",
Namespaced: false,
Kind: MachineDriverGroupVersionKind.Kind,
}
)
type MachineDriverList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []MachineDriver
}
type MachineDriverHandlerFunc func(key string, obj *MachineDriver) error
type MachineDriverLister interface {
List(namespace string, selector labels.Selector) (ret []*MachineDriver, err error)
Get(namespace, name string) (*MachineDriver, error)
}
type MachineDriverController interface {
Informer() cache.SharedIndexInformer
Lister() MachineDriverLister
AddHandler(handler MachineDriverHandlerFunc)
Enqueue(namespace, name string)
Sync(ctx context.Context) error
Start(ctx context.Context, threadiness int) error
}
type MachineDriverInterface interface {
ObjectClient() *clientbase.ObjectClient
Create(*MachineDriver) (*MachineDriver, error)
Get(name string, opts metav1.GetOptions) (*MachineDriver, error)
Update(*MachineDriver) (*MachineDriver, error)
Delete(name string, options *metav1.DeleteOptions) error
List(opts metav1.ListOptions) (*MachineDriverList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
Controller() MachineDriverController
}
type machineDriverLister struct {
controller *machineDriverController
}
func (l *machineDriverLister) List(namespace string, selector labels.Selector) (ret []*MachineDriver, err error) {
err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
ret = append(ret, obj.(*MachineDriver))
})
return
}
func (l *machineDriverLister) Get(namespace, name string) (*MachineDriver, error) {
obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(schema.GroupResource{
Group: MachineDriverGroupVersionKind.Group,
Resource: "machineDriver",
}, name)
}
return obj.(*MachineDriver), nil
}
type machineDriverController struct {
controller.GenericController
}
func (c *machineDriverController) Lister() MachineDriverLister {
return &machineDriverLister{
controller: c,
}
}
func (c *machineDriverController) AddHandler(handler MachineDriverHandlerFunc) {
c.GenericController.AddHandler(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.(*MachineDriver))
})
}
type machineDriverFactory struct {
}
func (c machineDriverFactory) Object() runtime.Object {
return &MachineDriver{}
}
func (c machineDriverFactory) List() runtime.Object {
return &MachineDriverList{}
}
func (s *machineDriverClient) Controller() MachineDriverController {
s.client.Lock()
defer s.client.Unlock()
c, ok := s.client.machineDriverControllers[s.ns]
if ok {
return c
}
genericController := controller.NewGenericController(MachineDriverGroupVersionKind.Kind+"Controller",
s.objectClient)
c = &machineDriverController{
GenericController: genericController,
}
s.client.machineDriverControllers[s.ns] = c
s.client.starters = append(s.client.starters, c)
return c
}
type machineDriverClient struct {
client *Client
ns string
objectClient *clientbase.ObjectClient
controller MachineDriverController
}
func (s *machineDriverClient) ObjectClient() *clientbase.ObjectClient {
return s.objectClient
}
func (s *machineDriverClient) Create(o *MachineDriver) (*MachineDriver, error) {
obj, err := s.objectClient.Create(o)
return obj.(*MachineDriver), err
}
func (s *machineDriverClient) Get(name string, opts metav1.GetOptions) (*MachineDriver, error) {
obj, err := s.objectClient.Get(name, opts)
return obj.(*MachineDriver), err
}
func (s *machineDriverClient) Update(o *MachineDriver) (*MachineDriver, error) {
obj, err := s.objectClient.Update(o.Name, o)
return obj.(*MachineDriver), err
}
func (s *machineDriverClient) Delete(name string, options *metav1.DeleteOptions) error {
return s.objectClient.Delete(name, options)
}
func (s *machineDriverClient) List(opts metav1.ListOptions) (*MachineDriverList, error) {
obj, err := s.objectClient.List(opts)
return obj.(*MachineDriverList), err
}
func (s *machineDriverClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return s.objectClient.Watch(opts)
}
func (s *machineDriverClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}

187
apis/cluster.cattle.io/v1/zz_generated_machine_template_controller.go
View File

@@ -1,187 +0,0 @@
package v1
import (
"context"
"github.com/rancher/norman/clientbase"
"github.com/rancher/norman/controller"
"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 (
MachineTemplateGroupVersionKind = schema.GroupVersionKind{
Version: "v1",
Group: "cluster.cattle.io",
Kind: "MachineTemplate",
}
MachineTemplateResource = metav1.APIResource{
Name: "machinetemplates",
SingularName: "machinetemplate",
Namespaced: false,
Kind: MachineTemplateGroupVersionKind.Kind,
}
)
type MachineTemplateList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []MachineTemplate
}
type MachineTemplateHandlerFunc func(key string, obj *MachineTemplate) error
type MachineTemplateLister interface {
List(namespace string, selector labels.Selector) (ret []*MachineTemplate, err error)
Get(namespace, name string) (*MachineTemplate, error)
}
type MachineTemplateController interface {
Informer() cache.SharedIndexInformer
Lister() MachineTemplateLister
AddHandler(handler MachineTemplateHandlerFunc)
Enqueue(namespace, name string)
Sync(ctx context.Context) error
Start(ctx context.Context, threadiness int) error
}
type MachineTemplateInterface interface {
ObjectClient() *clientbase.ObjectClient
Create(*MachineTemplate) (*MachineTemplate, error)
Get(name string, opts metav1.GetOptions) (*MachineTemplate, error)
Update(*MachineTemplate) (*MachineTemplate, error)
Delete(name string, options *metav1.DeleteOptions) error
List(opts metav1.ListOptions) (*MachineTemplateList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
Controller() MachineTemplateController
}
type machineTemplateLister struct {
controller *machineTemplateController
}
func (l *machineTemplateLister) List(namespace string, selector labels.Selector) (ret []*MachineTemplate, err error) {
err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
ret = append(ret, obj.(*MachineTemplate))
})
return
}
func (l *machineTemplateLister) Get(namespace, name string) (*MachineTemplate, error) {
obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(schema.GroupResource{
Group: MachineTemplateGroupVersionKind.Group,
Resource: "machineTemplate",
}, name)
}
return obj.(*MachineTemplate), nil
}
type machineTemplateController struct {
controller.GenericController
}
func (c *machineTemplateController) Lister() MachineTemplateLister {
return &machineTemplateLister{
controller: c,
}
}
func (c *machineTemplateController) AddHandler(handler MachineTemplateHandlerFunc) {
c.GenericController.AddHandler(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.(*MachineTemplate))
})
}
type machineTemplateFactory struct {
}
func (c machineTemplateFactory) Object() runtime.Object {
return &MachineTemplate{}
}
func (c machineTemplateFactory) List() runtime.Object {
return &MachineTemplateList{}
}
func (s *machineTemplateClient) Controller() MachineTemplateController {
s.client.Lock()
defer s.client.Unlock()
c, ok := s.client.machineTemplateControllers[s.ns]
if ok {
return c
}
genericController := controller.NewGenericController(MachineTemplateGroupVersionKind.Kind+"Controller",
s.objectClient)
c = &machineTemplateController{
GenericController: genericController,
}
s.client.machineTemplateControllers[s.ns] = c
s.client.starters = append(s.client.starters, c)
return c
}
type machineTemplateClient struct {
client *Client
ns string
objectClient *clientbase.ObjectClient
controller MachineTemplateController
}
func (s *machineTemplateClient) ObjectClient() *clientbase.ObjectClient {
return s.objectClient
}
func (s *machineTemplateClient) Create(o *MachineTemplate) (*MachineTemplate, error) {
obj, err := s.objectClient.Create(o)
return obj.(*MachineTemplate), err
}
func (s *machineTemplateClient) Get(name string, opts metav1.GetOptions) (*MachineTemplate, error) {
obj, err := s.objectClient.Get(name, opts)
return obj.(*MachineTemplate), err
}
func (s *machineTemplateClient) Update(o *MachineTemplate) (*MachineTemplate, error) {
obj, err := s.objectClient.Update(o.Name, o)
return obj.(*MachineTemplate), err
}
func (s *machineTemplateClient) Delete(name string, options *metav1.DeleteOptions) error {
return s.objectClient.Delete(name, options)
}
func (s *machineTemplateClient) List(opts metav1.ListOptions) (*MachineTemplateList, error) {
obj, err := s.objectClient.List(opts)
return obj.(*MachineTemplateList), err
}
func (s *machineTemplateClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return s.objectClient.Watch(opts)
}
func (s *machineTemplateClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}