rancher/types
1
0
Fork 0
mirror of https://github.com/rancher/types.git synced 2025-07-11 20:37:58 +00:00
Code Issues Releases Wiki Activity

Go generated

Browse Source
This commit is contained in:
Frank Mai 2019-08-06 11:01:19 +08:00 committed by Alena Prokharchyk
parent 719551e498
commit 376c6f64c7
11 changed files with 2 additions and 2516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1740
apis/management.cattle.io/v3/fakes/zz_generated_rke_k8s_windows_system_image_mock.go
View File

File diff suppressed because it is too large Load Diff

61
apis/management.cattle.io/v3/zz_generated_deepcopy.go
View File

@ -7940,67 +7940,6 @@ func (in *RKEK8sSystemImageList) DeepCopyObject() runtime.Object {
return nil
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RKEK8sWindowsSystemImage) DeepCopyInto(out *RKEK8sWindowsSystemImage) {
*out = *in
out.Namespaced = in.Namespaced
out.TypeMeta = in.TypeMeta
in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
out.SystemImages = in.SystemImages
return
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEK8sWindowsSystemImage.
func (in *RKEK8sWindowsSystemImage) DeepCopy() *RKEK8sWindowsSystemImage {
if in == nil {
return nil
}
out := new(RKEK8sWindowsSystemImage)
in.DeepCopyInto(out)
return out
}
// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *RKEK8sWindowsSystemImage) DeepCopyObject() runtime.Object {
if c := in.DeepCopy(); c != nil {
return c
}
return nil
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RKEK8sWindowsSystemImageList) DeepCopyInto(out *RKEK8sWindowsSystemImageList) {
*out = *in
out.TypeMeta = in.TypeMeta
out.ListMeta = in.ListMeta
if in.Items != nil {
in, out := &in.Items, &out.Items
*out = make([]RKEK8sWindowsSystemImage, len(*in))
for i := range *in {
(*in)[i].DeepCopyInto(&(*out)[i])
}
}
return
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RKEK8sWindowsSystemImageList.
func (in *RKEK8sWindowsSystemImageList) DeepCopy() *RKEK8sWindowsSystemImageList {
if in == nil {
return nil
}
out := new(RKEK8sWindowsSystemImageList)
in.DeepCopyInto(out)
return out
}
// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *RKEK8sWindowsSystemImageList) DeepCopyObject() runtime.Object {
if c := in.DeepCopy(); c != nil {
return c
}
return nil
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RKEPlan) DeepCopyInto(out *RKEPlan) {
*out = *in

20
apis/management.cattle.io/v3/zz_generated_k8s_client.go
View File

@ -82,7 +82,6 @@ type Interface interface {
RKEK8sSystemImagesGetter
RKEK8sServiceOptionsGetter
RKEAddonsGetter
RKEK8sWindowsSystemImagesGetter
}
type Clients struct {
@ -150,7 +149,6 @@ type Clients struct {
RKEK8sSystemImage RKEK8sSystemImageClient
RKEK8sServiceOption RKEK8sServiceOptionClient
RKEAddon RKEAddonClient
RKEK8sWindowsSystemImage RKEK8sWindowsSystemImageClient
}
type Client struct {
@ -220,7 +218,6 @@ type Client struct {
rkeK8sSystemImageControllers map[string]RKEK8sSystemImageController
rkeK8sServiceOptionControllers map[string]RKEK8sServiceOptionController
rkeAddonControllers map[string]RKEAddonController
rkeK8sWindowsSystemImageControllers map[string]RKEK8sWindowsSystemImageController
}
func Factory(ctx context.Context, config rest.Config) (context.Context, controller.Starter, error) {
@ -442,9 +439,6 @@ func NewClientsFromInterface(iface Interface) *Clients {
RKEAddon: &rkeAddonClient2{
iface: iface.RKEAddons(""),
},
RKEK8sWindowsSystemImage: &rkeK8sWindowsSystemImageClient2{
iface: iface.RKEK8sWindowsSystemImages(""),
},
}
}
@ -523,7 +517,6 @@ func NewForConfig(config rest.Config) (Interface, error) {
rkeK8sSystemImageControllers: map[string]RKEK8sSystemImageController{},
rkeK8sServiceOptionControllers: map[string]RKEK8sServiceOptionController{},
rkeAddonControllers: map[string]RKEAddonController{},
rkeK8sWindowsSystemImageControllers: map[string]RKEK8sWindowsSystemImageController{},
}, nil
}
@ -1344,16 +1337,3 @@ func (c *Client) RKEAddons(namespace string) RKEAddonInterface {
objectClient: objectClient,
}
}
type RKEK8sWindowsSystemImagesGetter interface {
RKEK8sWindowsSystemImages(namespace string) RKEK8sWindowsSystemImageInterface
}
func (c *Client) RKEK8sWindowsSystemImages(namespace string) RKEK8sWindowsSystemImageInterface {
objectClient := objectclient.NewObjectClient(namespace, c.restClient, &RKEK8sWindowsSystemImageResource, RKEK8sWindowsSystemImageGroupVersionKind, rkeK8sWindowsSystemImageFactory{})
return &rkeK8sWindowsSystemImageClient{
ns: namespace,
client: c,
objectClient: objectClient,
}
}

503
apis/management.cattle.io/v3/zz_generated_rke_k8s_windows_system_image_controller.go
View File

@ -1,503 +0,0 @@
package v3
import (
"context"
"github.com/rancher/norman/controller"
"github.com/rancher/norman/objectclient"
"github.com/rancher/norman/resource"
"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/types"
"k8s.io/apimachinery/pkg/watch"
"k8s.io/client-go/tools/cache"
)
var (
RKEK8sWindowsSystemImageGroupVersionKind = schema.GroupVersionKind{
Version: Version,
Group: GroupName,
Kind: "RKEK8sWindowsSystemImage",
}
RKEK8sWindowsSystemImageResource = metav1.APIResource{
Name: "rkek8swindowssystemimages",
SingularName: "rkek8swindowssystemimage",
Namespaced: true,
Kind: RKEK8sWindowsSystemImageGroupVersionKind.Kind,
}
RKEK8sWindowsSystemImageGroupVersionResource = schema.GroupVersionResource{
Group: GroupName,
Version: Version,
Resource: "rkek8swindowssystemimages",
}
)
func init() {
resource.Put(RKEK8sWindowsSystemImageGroupVersionResource)
}
func NewRKEK8sWindowsSystemImage(namespace, name string, obj RKEK8sWindowsSystemImage) *RKEK8sWindowsSystemImage {
obj.APIVersion, obj.Kind = RKEK8sWindowsSystemImageGroupVersionKind.ToAPIVersionAndKind()
obj.Name = name
obj.Namespace = namespace
return &obj
}
type RKEK8sWindowsSystemImageList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []RKEK8sWindowsSystemImage `json:"items"`
}
type RKEK8sWindowsSystemImageHandlerFunc func(key string, obj *RKEK8sWindowsSystemImage) (runtime.Object, error)
type RKEK8sWindowsSystemImageChangeHandlerFunc func(obj *RKEK8sWindowsSystemImage) (runtime.Object, error)
type RKEK8sWindowsSystemImageLister interface {
List(namespace string, selector labels.Selector) (ret []*RKEK8sWindowsSystemImage, err error)
Get(namespace, name string) (*RKEK8sWindowsSystemImage, error)
}
type RKEK8sWindowsSystemImageController interface {
Generic() controller.GenericController
Informer() cache.SharedIndexInformer
Lister() RKEK8sWindowsSystemImageLister
AddHandler(ctx context.Context, name string, handler RKEK8sWindowsSystemImageHandlerFunc)
AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sWindowsSystemImageHandlerFunc)
AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler RKEK8sWindowsSystemImageHandlerFunc)
AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler RKEK8sWindowsSystemImageHandlerFunc)
Enqueue(namespace, name string)
Sync(ctx context.Context) error
Start(ctx context.Context, threadiness int) error
}
type RKEK8sWindowsSystemImageInterface interface {
ObjectClient() *objectclient.ObjectClient
Create(*RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error)
GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RKEK8sWindowsSystemImage, error)
Get(name string, opts metav1.GetOptions) (*RKEK8sWindowsSystemImage, error)
Update(*RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error)
Delete(name string, options *metav1.DeleteOptions) error
DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
List(opts metav1.ListOptions) (*RKEK8sWindowsSystemImageList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
Controller() RKEK8sWindowsSystemImageController
AddHandler(ctx context.Context, name string, sync RKEK8sWindowsSystemImageHandlerFunc)
AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sWindowsSystemImageHandlerFunc)
AddLifecycle(ctx context.Context, name string, lifecycle RKEK8sWindowsSystemImageLifecycle)
AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle RKEK8sWindowsSystemImageLifecycle)
AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RKEK8sWindowsSystemImageHandlerFunc)
AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync RKEK8sWindowsSystemImageHandlerFunc)
AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RKEK8sWindowsSystemImageLifecycle)
AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle RKEK8sWindowsSystemImageLifecycle)
}
type rkeK8sWindowsSystemImageLister struct {
controller *rkeK8sWindowsSystemImageController
}
func (l *rkeK8sWindowsSystemImageLister) List(namespace string, selector labels.Selector) (ret []*RKEK8sWindowsSystemImage, err error) {
err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
ret = append(ret, obj.(*RKEK8sWindowsSystemImage))
})
return
}
func (l *rkeK8sWindowsSystemImageLister) Get(namespace, name string) (*RKEK8sWindowsSystemImage, 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: RKEK8sWindowsSystemImageGroupVersionKind.Group,
Resource: "rkeK8sWindowsSystemImage",
}, key)
}
return obj.(*RKEK8sWindowsSystemImage), nil
}
type rkeK8sWindowsSystemImageController struct {
controller.GenericController
}
func (c *rkeK8sWindowsSystemImageController) Generic() controller.GenericController {
return c.GenericController
}
func (c *rkeK8sWindowsSystemImageController) Lister() RKEK8sWindowsSystemImageLister {
return &rkeK8sWindowsSystemImageLister{
controller: c,
}
}
func (c *rkeK8sWindowsSystemImageController) AddHandler(ctx context.Context, name string, handler RKEK8sWindowsSystemImageHandlerFunc) {
c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
if obj == nil {
return handler(key, nil)
} else if v, ok := obj.(*RKEK8sWindowsSystemImage); ok {
return handler(key, v)
} else {
return nil, nil
}
})
}
func (c *rkeK8sWindowsSystemImageController) AddFeatureHandler(ctx context.Context, enabled func() bool, name string, handler RKEK8sWindowsSystemImageHandlerFunc) {
c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
if !enabled() {
return nil, nil
} else if obj == nil {
return handler(key, nil)
} else if v, ok := obj.(*RKEK8sWindowsSystemImage); ok {
return handler(key, v)
} else {
return nil, nil
}
})
}
func (c *rkeK8sWindowsSystemImageController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler RKEK8sWindowsSystemImageHandlerFunc) {
c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
if obj == nil {
return handler(key, nil)
} else if v, ok := obj.(*RKEK8sWindowsSystemImage); ok && controller.ObjectInCluster(cluster, obj) {
return handler(key, v)
} else {
return nil, nil
}
})
}
func (c *rkeK8sWindowsSystemImageController) AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, cluster string, handler RKEK8sWindowsSystemImageHandlerFunc) {
c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
if !enabled() {
return nil, nil
} else if obj == nil {
return handler(key, nil)
} else if v, ok := obj.(*RKEK8sWindowsSystemImage); ok && controller.ObjectInCluster(cluster, obj) {
return handler(key, v)
} else {
return nil, nil
}
})
}
type rkeK8sWindowsSystemImageFactory struct {
}
func (c rkeK8sWindowsSystemImageFactory) Object() runtime.Object {
return &RKEK8sWindowsSystemImage{}
}
func (c rkeK8sWindowsSystemImageFactory) List() runtime.Object {
return &RKEK8sWindowsSystemImageList{}
}
func (s *rkeK8sWindowsSystemImageClient) Controller() RKEK8sWindowsSystemImageController {
s.client.Lock()
defer s.client.Unlock()
c, ok := s.client.rkeK8sWindowsSystemImageControllers[s.ns]
if ok {
return c
}
genericController := controller.NewGenericController(RKEK8sWindowsSystemImageGroupVersionKind.Kind+"Controller",
s.objectClient)
c = &rkeK8sWindowsSystemImageController{
GenericController: genericController,
}
s.client.rkeK8sWindowsSystemImageControllers[s.ns] = c
s.client.starters = append(s.client.starters, c)
return c
}
type rkeK8sWindowsSystemImageClient struct {
client *Client
ns string
objectClient *objectclient.ObjectClient
controller RKEK8sWindowsSystemImageController
}
func (s *rkeK8sWindowsSystemImageClient) ObjectClient() *objectclient.ObjectClient {
return s.objectClient
}
func (s *rkeK8sWindowsSystemImageClient) Create(o *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error) {
obj, err := s.objectClient.Create(o)
return obj.(*RKEK8sWindowsSystemImage), err
}
func (s *rkeK8sWindowsSystemImageClient) Get(name string, opts metav1.GetOptions) (*RKEK8sWindowsSystemImage, error) {
obj, err := s.objectClient.Get(name, opts)
return obj.(*RKEK8sWindowsSystemImage), err
}
func (s *rkeK8sWindowsSystemImageClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*RKEK8sWindowsSystemImage, error) {
obj, err := s.objectClient.GetNamespaced(namespace, name, opts)
return obj.(*RKEK8sWindowsSystemImage), err
}
func (s *rkeK8sWindowsSystemImageClient) Update(o *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error) {
obj, err := s.objectClient.Update(o.Name, o)
return obj.(*RKEK8sWindowsSystemImage), err
}
func (s *rkeK8sWindowsSystemImageClient) Delete(name string, options *metav1.DeleteOptions) error {
return s.objectClient.Delete(name, options)
}
func (s *rkeK8sWindowsSystemImageClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error {
return s.objectClient.DeleteNamespaced(namespace, name, options)
}
func (s *rkeK8sWindowsSystemImageClient) List(opts metav1.ListOptions) (*RKEK8sWindowsSystemImageList, error) {
obj, err := s.objectClient.List(opts)
return obj.(*RKEK8sWindowsSystemImageList), err
}
func (s *rkeK8sWindowsSystemImageClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return s.objectClient.Watch(opts)
}
// Patch applies the patch and returns the patched deployment.
func (s *rkeK8sWindowsSystemImageClient) Patch(o *RKEK8sWindowsSystemImage, patchType types.PatchType, data []byte, subresources ...string) (*RKEK8sWindowsSystemImage, error) {
obj, err := s.objectClient.Patch(o.Name, o, patchType, data, subresources...)
return obj.(*RKEK8sWindowsSystemImage), err
}
func (s *rkeK8sWindowsSystemImageClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}
func (s *rkeK8sWindowsSystemImageClient) AddHandler(ctx context.Context, name string, sync RKEK8sWindowsSystemImageHandlerFunc) {
s.Controller().AddHandler(ctx, name, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync RKEK8sWindowsSystemImageHandlerFunc) {
s.Controller().AddFeatureHandler(ctx, enabled, name, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddLifecycle(ctx context.Context, name string, lifecycle RKEK8sWindowsSystemImageLifecycle) {
sync := NewRKEK8sWindowsSystemImageLifecycleAdapter(name, false, s, lifecycle)
s.Controller().AddHandler(ctx, name, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle RKEK8sWindowsSystemImageLifecycle) {
sync := NewRKEK8sWindowsSystemImageLifecycleAdapter(name, false, s, lifecycle)
s.Controller().AddFeatureHandler(ctx, enabled, name, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync RKEK8sWindowsSystemImageHandlerFunc) {
s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync RKEK8sWindowsSystemImageHandlerFunc) {
s.Controller().AddClusterScopedFeatureHandler(ctx, enabled, name, clusterName, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle RKEK8sWindowsSystemImageLifecycle) {
sync := NewRKEK8sWindowsSystemImageLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle)
s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync)
}
func (s *rkeK8sWindowsSystemImageClient) AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle RKEK8sWindowsSystemImageLifecycle) {
sync := NewRKEK8sWindowsSystemImageLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle)
s.Controller().AddClusterScopedFeatureHandler(ctx, enabled, name, clusterName, sync)
}
type RKEK8sWindowsSystemImageIndexer func(obj *RKEK8sWindowsSystemImage) ([]string, error)
type RKEK8sWindowsSystemImageClientCache interface {
Get(namespace, name string) (*RKEK8sWindowsSystemImage, error)
List(namespace string, selector labels.Selector) ([]*RKEK8sWindowsSystemImage, error)
Index(name string, indexer RKEK8sWindowsSystemImageIndexer)
GetIndexed(name, key string) ([]*RKEK8sWindowsSystemImage, error)
}
type RKEK8sWindowsSystemImageClient interface {
Create(*RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error)
Get(namespace, name string, opts metav1.GetOptions) (*RKEK8sWindowsSystemImage, error)
Update(*RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error)
Delete(namespace, name string, options *metav1.DeleteOptions) error
List(namespace string, opts metav1.ListOptions) (*RKEK8sWindowsSystemImageList, error)
Watch(opts metav1.ListOptions) (watch.Interface, error)
Cache() RKEK8sWindowsSystemImageClientCache
OnCreate(ctx context.Context, name string, sync RKEK8sWindowsSystemImageChangeHandlerFunc)
OnChange(ctx context.Context, name string, sync RKEK8sWindowsSystemImageChangeHandlerFunc)
OnRemove(ctx context.Context, name string, sync RKEK8sWindowsSystemImageChangeHandlerFunc)
Enqueue(namespace, name string)
Generic() controller.GenericController
ObjectClient() *objectclient.ObjectClient
Interface() RKEK8sWindowsSystemImageInterface
}
type rkeK8sWindowsSystemImageClientCache struct {
client *rkeK8sWindowsSystemImageClient2
}
type rkeK8sWindowsSystemImageClient2 struct {
iface RKEK8sWindowsSystemImageInterface
controller RKEK8sWindowsSystemImageController
}
func (n *rkeK8sWindowsSystemImageClient2) Interface() RKEK8sWindowsSystemImageInterface {
return n.iface
}
func (n *rkeK8sWindowsSystemImageClient2) Generic() controller.GenericController {
return n.iface.Controller().Generic()
}
func (n *rkeK8sWindowsSystemImageClient2) ObjectClient() *objectclient.ObjectClient {
return n.Interface().ObjectClient()
}
func (n *rkeK8sWindowsSystemImageClient2) Enqueue(namespace, name string) {
n.iface.Controller().Enqueue(namespace, name)
}
func (n *rkeK8sWindowsSystemImageClient2) Create(obj *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error) {
return n.iface.Create(obj)
}
func (n *rkeK8sWindowsSystemImageClient2) Get(namespace, name string, opts metav1.GetOptions) (*RKEK8sWindowsSystemImage, error) {
return n.iface.GetNamespaced(namespace, name, opts)
}
func (n *rkeK8sWindowsSystemImageClient2) Update(obj *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error) {
return n.iface.Update(obj)
}
func (n *rkeK8sWindowsSystemImageClient2) Delete(namespace, name string, options *metav1.DeleteOptions) error {
return n.iface.DeleteNamespaced(namespace, name, options)
}
func (n *rkeK8sWindowsSystemImageClient2) List(namespace string, opts metav1.ListOptions) (*RKEK8sWindowsSystemImageList, error) {
return n.iface.List(opts)
}
func (n *rkeK8sWindowsSystemImageClient2) Watch(opts metav1.ListOptions) (watch.Interface, error) {
return n.iface.Watch(opts)
}
func (n *rkeK8sWindowsSystemImageClientCache) Get(namespace, name string) (*RKEK8sWindowsSystemImage, error) {
return n.client.controller.Lister().Get(namespace, name)
}
func (n *rkeK8sWindowsSystemImageClientCache) List(namespace string, selector labels.Selector) ([]*RKEK8sWindowsSystemImage, error) {
return n.client.controller.Lister().List(namespace, selector)
}
func (n *rkeK8sWindowsSystemImageClient2) Cache() RKEK8sWindowsSystemImageClientCache {
n.loadController()
return &rkeK8sWindowsSystemImageClientCache{
client: n,
}
}
func (n *rkeK8sWindowsSystemImageClient2) OnCreate(ctx context.Context, name string, sync RKEK8sWindowsSystemImageChangeHandlerFunc) {
n.loadController()
n.iface.AddLifecycle(ctx, name+"-create", &rkeK8sWindowsSystemImageLifecycleDelegate{create: sync})
}
func (n *rkeK8sWindowsSystemImageClient2) OnChange(ctx context.Context, name string, sync RKEK8sWindowsSystemImageChangeHandlerFunc) {
n.loadController()
n.iface.AddLifecycle(ctx, name+"-change", &rkeK8sWindowsSystemImageLifecycleDelegate{update: sync})
}
func (n *rkeK8sWindowsSystemImageClient2) OnRemove(ctx context.Context, name string, sync RKEK8sWindowsSystemImageChangeHandlerFunc) {
n.loadController()
n.iface.AddLifecycle(ctx, name, &rkeK8sWindowsSystemImageLifecycleDelegate{remove: sync})
}
func (n *rkeK8sWindowsSystemImageClientCache) Index(name string, indexer RKEK8sWindowsSystemImageIndexer) {
err := n.client.controller.Informer().GetIndexer().AddIndexers(map[string]cache.IndexFunc{
name: func(obj interface{}) ([]string, error) {
if v, ok := obj.(*RKEK8sWindowsSystemImage); ok {
return indexer(v)
}
return nil, nil
},
})
if err != nil {
panic(err)
}
}
func (n *rkeK8sWindowsSystemImageClientCache) GetIndexed(name, key string) ([]*RKEK8sWindowsSystemImage, error) {
var result []*RKEK8sWindowsSystemImage
objs, err := n.client.controller.Informer().GetIndexer().ByIndex(name, key)
if err != nil {
return nil, err
}
for _, obj := range objs {
if v, ok := obj.(*RKEK8sWindowsSystemImage); ok {
result = append(result, v)
}
}
return result, nil
}
func (n *rkeK8sWindowsSystemImageClient2) loadController() {
if n.controller == nil {
n.controller = n.iface.Controller()
}
}
type rkeK8sWindowsSystemImageLifecycleDelegate struct {
create RKEK8sWindowsSystemImageChangeHandlerFunc
update RKEK8sWindowsSystemImageChangeHandlerFunc
remove RKEK8sWindowsSystemImageChangeHandlerFunc
}
func (n *rkeK8sWindowsSystemImageLifecycleDelegate) HasCreate() bool {
return n.create != nil
}
func (n *rkeK8sWindowsSystemImageLifecycleDelegate) Create(obj *RKEK8sWindowsSystemImage) (runtime.Object, error) {
if n.create == nil {
return obj, nil
}
return n.create(obj)
}
func (n *rkeK8sWindowsSystemImageLifecycleDelegate) HasFinalize() bool {
return n.remove != nil
}
func (n *rkeK8sWindowsSystemImageLifecycleDelegate) Remove(obj *RKEK8sWindowsSystemImage) (runtime.Object, error) {
if n.remove == nil {
return obj, nil
}
return n.remove(obj)
}
func (n *rkeK8sWindowsSystemImageLifecycleDelegate) Updated(obj *RKEK8sWindowsSystemImage) (runtime.Object, error) {
if n.update == nil {
return obj, nil
}
return n.update(obj)
}

66
apis/management.cattle.io/v3/zz_generated_rke_k8s_windows_system_image_lifecycle_adapter.go
View File

@ -1,66 +0,0 @@
package v3
import (
"github.com/rancher/norman/lifecycle"
"github.com/rancher/norman/resource"
"k8s.io/apimachinery/pkg/runtime"
)
type RKEK8sWindowsSystemImageLifecycle interface {
Create(obj *RKEK8sWindowsSystemImage) (runtime.Object, error)
Remove(obj *RKEK8sWindowsSystemImage) (runtime.Object, error)
Updated(obj *RKEK8sWindowsSystemImage) (runtime.Object, error)
}
type rkeK8sWindowsSystemImageLifecycleAdapter struct {
lifecycle RKEK8sWindowsSystemImageLifecycle
}
func (w *rkeK8sWindowsSystemImageLifecycleAdapter) HasCreate() bool {
o, ok := w.lifecycle.(lifecycle.ObjectLifecycleCondition)
return !ok || o.HasCreate()
}
func (w *rkeK8sWindowsSystemImageLifecycleAdapter) HasFinalize() bool {
o, ok := w.lifecycle.(lifecycle.ObjectLifecycleCondition)
return !ok || o.HasFinalize()
}
func (w *rkeK8sWindowsSystemImageLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) {
o, err := w.lifecycle.Create(obj.(*RKEK8sWindowsSystemImage))
if o == nil {
return nil, err
}
return o, err
}
func (w *rkeK8sWindowsSystemImageLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) {
o, err := w.lifecycle.Remove(obj.(*RKEK8sWindowsSystemImage))
if o == nil {
return nil, err
}
return o, err
}
func (w *rkeK8sWindowsSystemImageLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) {
o, err := w.lifecycle.Updated(obj.(*RKEK8sWindowsSystemImage))
if o == nil {
return nil, err
}
return o, err
}
func NewRKEK8sWindowsSystemImageLifecycleAdapter(name string, clusterScoped bool, client RKEK8sWindowsSystemImageInterface, l RKEK8sWindowsSystemImageLifecycle) RKEK8sWindowsSystemImageHandlerFunc {
if clusterScoped {
resource.PutClusterScoped(RKEK8sWindowsSystemImageGroupVersionResource)
}
adapter := &rkeK8sWindowsSystemImageLifecycleAdapter{lifecycle: l}
syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient())
return func(key string, obj *RKEK8sWindowsSystemImage) (runtime.Object, error) {
newObj, err := syncFn(key, obj)
if o, ok := newObj.(runtime.Object); ok {
return o, err
}
return nil, err
}
}

2
apis/management.cattle.io/v3/zz_generated_scheme.go
View File

@ -157,8 +157,6 @@ func addKnownTypes(scheme *runtime.Scheme) error {
&RKEK8sServiceOptionList{},
&RKEAddon{},
&RKEAddonList{},
&RKEK8sWindowsSystemImage{},
&RKEK8sWindowsSystemImageList{},
)
metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
return nil

2
client/management/v3/zz_generated_client.go
View File

@ -69,7 +69,6 @@ type Client struct {
RKEK8sSystemImage RKEK8sSystemImageOperations
RKEK8sServiceOption RKEK8sServiceOptionOperations
RKEAddon RKEAddonOperations
RKEK8sWindowsSystemImage RKEK8sWindowsSystemImageOperations
}
func NewClient(opts *clientbase.ClientOpts) (*Client, error) {
@ -144,7 +143,6 @@ func NewClient(opts *clientbase.ClientOpts) (*Client, error) {
client.RKEK8sSystemImage = newRKEK8sSystemImageClient(client)
client.RKEK8sServiceOption = newRKEK8sServiceOptionClient(client)
client.RKEAddon = newRKEAddonClient(client)
client.RKEK8sWindowsSystemImage = newRKEK8sWindowsSystemImageClient(client)
return client, nil
}

101
client/management/v3/zz_generated_rke_k8s_windows_system_image.go
View File

@ -1,101 +0,0 @@
package client
import (
"github.com/rancher/norman/types"
)
const (
RKEK8sWindowsSystemImageType = "rkeK8sWindowsSystemImage"
RKEK8sWindowsSystemImageFieldAnnotations = "annotations"
RKEK8sWindowsSystemImageFieldCreated = "created"
RKEK8sWindowsSystemImageFieldCreatorID = "creatorId"
RKEK8sWindowsSystemImageFieldLabels = "labels"
RKEK8sWindowsSystemImageFieldName = "name"
RKEK8sWindowsSystemImageFieldOwnerReferences = "ownerReferences"
RKEK8sWindowsSystemImageFieldRemoved = "removed"
RKEK8sWindowsSystemImageFieldSystemImages = "windowsSystemImages"
RKEK8sWindowsSystemImageFieldUUID = "uuid"
)
type RKEK8sWindowsSystemImage struct {
types.Resource
Annotations map[string]string `json:"annotations,omitempty" yaml:"annotations,omitempty"`
Created string `json:"created,omitempty" yaml:"created,omitempty"`
CreatorID string `json:"creatorId,omitempty" yaml:"creatorId,omitempty"`
Labels map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
Name string `json:"name,omitempty" yaml:"name,omitempty"`
OwnerReferences []OwnerReference `json:"ownerReferences,omitempty" yaml:"ownerReferences,omitempty"`
Removed string `json:"removed,omitempty" yaml:"removed,omitempty"`
SystemImages *WindowsSystemImages `json:"windowsSystemImages,omitempty" yaml:"windowsSystemImages,omitempty"`
UUID string `json:"uuid,omitempty" yaml:"uuid,omitempty"`
}
type RKEK8sWindowsSystemImageCollection struct {
types.Collection
Data []RKEK8sWindowsSystemImage `json:"data,omitempty"`
client *RKEK8sWindowsSystemImageClient
}
type RKEK8sWindowsSystemImageClient struct {
apiClient *Client
}
type RKEK8sWindowsSystemImageOperations interface {
List(opts *types.ListOpts) (*RKEK8sWindowsSystemImageCollection, error)
Create(opts *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error)
Update(existing *RKEK8sWindowsSystemImage, updates interface{}) (*RKEK8sWindowsSystemImage, error)
Replace(existing *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error)
ByID(id string) (*RKEK8sWindowsSystemImage, error)
Delete(container *RKEK8sWindowsSystemImage) error
}
func newRKEK8sWindowsSystemImageClient(apiClient *Client) *RKEK8sWindowsSystemImageClient {
return &RKEK8sWindowsSystemImageClient{
apiClient: apiClient,
}
}
func (c *RKEK8sWindowsSystemImageClient) Create(container *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error) {
resp := &RKEK8sWindowsSystemImage{}
err := c.apiClient.Ops.DoCreate(RKEK8sWindowsSystemImageType, container, resp)
return resp, err
}
func (c *RKEK8sWindowsSystemImageClient) Update(existing *RKEK8sWindowsSystemImage, updates interface{}) (*RKEK8sWindowsSystemImage, error) {
resp := &RKEK8sWindowsSystemImage{}
err := c.apiClient.Ops.DoUpdate(RKEK8sWindowsSystemImageType, &existing.Resource, updates, resp)
return resp, err
}
func (c *RKEK8sWindowsSystemImageClient) Replace(obj *RKEK8sWindowsSystemImage) (*RKEK8sWindowsSystemImage, error) {
resp := &RKEK8sWindowsSystemImage{}
err := c.apiClient.Ops.DoReplace(RKEK8sWindowsSystemImageType, &obj.Resource, obj, resp)
return resp, err
}
func (c *RKEK8sWindowsSystemImageClient) List(opts *types.ListOpts) (*RKEK8sWindowsSystemImageCollection, error) {
resp := &RKEK8sWindowsSystemImageCollection{}
err := c.apiClient.Ops.DoList(RKEK8sWindowsSystemImageType, opts, resp)
resp.client = c
return resp, err
}
func (cc *RKEK8sWindowsSystemImageCollection) Next() (*RKEK8sWindowsSystemImageCollection, error) {
if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" {
resp := &RKEK8sWindowsSystemImageCollection{}
err := cc.client.apiClient.Ops.DoNext(cc.Pagination.Next, resp)
resp.client = cc.client
return resp, err
}
return nil, nil
}
func (c *RKEK8sWindowsSystemImageClient) ByID(id string) (*RKEK8sWindowsSystemImage, error) {
resp := &RKEK8sWindowsSystemImage{}
err := c.apiClient.Ops.DoByID(RKEK8sWindowsSystemImageType, id, resp)
return resp, err
}
func (c *RKEK8sWindowsSystemImageClient) Delete(container *RKEK8sWindowsSystemImage) error {
return c.apiClient.Ops.DoResourceDelete(RKEK8sWindowsSystemImageType, &container.Resource)
}

2
client/management/v3/zz_generated_rke_system_images.go
View File

@ -31,6 +31,7 @@ const (
RKESystemImagesFieldPodInfraContainer = "podInfraContainer"
RKESystemImagesFieldWeaveCNI = "weaveCni"
RKESystemImagesFieldWeaveNode = "weaveNode"
RKESystemImagesFieldWindowsPodInfraContainer = "podInfraWindowsContainer"
)
type RKESystemImages struct {
@ -63,4 +64,5 @@ type RKESystemImages struct {
PodInfraContainer string `json:"podInfraContainer,omitempty" yaml:"podInfraContainer,omitempty"`
WeaveCNI string `json:"weaveCni,omitempty" yaml:"weaveCni,omitempty"`
WeaveNode string `json:"weaveNode,omitempty" yaml:"weaveNode,omitempty"`
WindowsPodInfraContainer string `json:"podInfraWindowsContainer,omitempty" yaml:"podInfraWindowsContainer,omitempty"`
}

20
client/management/v3/zz_generated_windows_system_images.go
View File

@ -1,20 +0,0 @@
package client
const (
WindowsSystemImagesType = "windowsSystemImages"
WindowsSystemImagesFieldCalicoCNIBinaries = "calicoCniBinaries"
WindowsSystemImagesFieldCanalCNIBinaries = "canalCniBinaries"
WindowsSystemImagesFieldFlannelCNIBinaries = "flannelCniBinaries"
WindowsSystemImagesFieldKubeletPause = "kubeletPause"
WindowsSystemImagesFieldKubernetesBinaries = "kubernetesBinaries"
WindowsSystemImagesFieldNginxProxy = "nginxProxy"
)
type WindowsSystemImages struct {
CalicoCNIBinaries string `json:"calicoCniBinaries,omitempty" yaml:"calicoCniBinaries,omitempty"`
CanalCNIBinaries string `json:"canalCniBinaries,omitempty" yaml:"canalCniBinaries,omitempty"`
FlannelCNIBinaries string `json:"flannelCniBinaries,omitempty" yaml:"flannelCniBinaries,omitempty"`
KubeletPause string `json:"kubeletPause,omitempty" yaml:"kubeletPause,omitempty"`
KubernetesBinaries string `json:"kubernetesBinaries,omitempty" yaml:"kubernetesBinaries,omitempty"`
NginxProxy string `json:"nginxProxy,omitempty" yaml:"nginxProxy,omitempty"`
}

1
compose/zz_generated_compose.go
View File

@ -67,7 +67,6 @@ type Config struct {
RKEK8sSystemImages map[string]managementClient.RKEK8sSystemImage `json:"rkeK8sSystemImages,omitempty" yaml:"rkeK8sSystemImages,omitempty"`
RKEK8sServiceOptions map[string]managementClient.RKEK8sServiceOption `json:"rkeK8sServiceOptions,omitempty" yaml:"rkeK8sServiceOptions,omitempty"`
RKEAddons map[string]managementClient.RKEAddon `json:"rkeAddons,omitempty" yaml:"rkeAddons,omitempty"`
RKEK8sWindowsSystemImages map[string]managementClient.RKEK8sWindowsSystemImage `json:"rkeK8sWindowsSystemImages,omitempty" yaml:"rkeK8sWindowsSystemImages,omitempty"`
// Cluster Client
Namespaces map[string]clusterClient.Namespace `json:"namespaces,omitempty" yaml:"namespaces,omitempty"`