From 39c0f9a1fcfa1e76d2dd54f9e006bd79235e06b5 Mon Sep 17 00:00:00 2001 From: Daishan Peng Date: Wed, 23 May 2018 10:22:06 -0700 Subject: [PATCH] generated changes --- ...rated_cluster_compose_config_controller.go | 252 ----------------- ...luster_compose_config_lifecycle_adapter.go | 51 ---- .../zz_generated_compose_config_controller.go | 251 +++++++++++++++++ ...erated_compose_config_lifecycle_adapter.go | 51 ++++ .../v3/zz_generated_deepcopy.go | 254 +++++++----------- ...erated_global_compose_config_controller.go | 251 ----------------- ...global_compose_config_lifecycle_adapter.go | 51 ---- .../v3/zz_generated_k8s_client.go | 32 +-- .../v3/zz_generated_scheme.go | 6 +- .../v3/zz_generated_deepcopy.go | 137 ---------- .../v3/zz_generated_k8s_client.go | 16 -- ...ted_namespace_compose_config_controller.go | 252 ----------------- ...espace_compose_config_lifecycle_adapter.go | 51 ---- .../v3/zz_generated_scheme.go | 2 - client/management/v3/zz_generated_client.go | 6 +- .../v3/zz_generated_cluster_compose_config.go | 105 -------- .../v3/zz_generated_cluster_compose_spec.go | 12 - .../v3/zz_generated_compose_config.go | 101 +++++++ .../v3/zz_generated_global_compose_config.go | 101 ------- client/management/v3/zz_generated_project.go | 7 + client/project/v3/zz_generated_client.go | 2 - .../v3/zz_generated_compose_condition.go | 20 -- .../project/v3/zz_generated_compose_status.go | 10 - .../zz_generated_namespace_compose_config.go | 107 -------- .../v3/zz_generated_namespace_compose_spec.go | 14 - compose/zz_generated_compose.go | 4 +- 26 files changed, 514 insertions(+), 1632 deletions(-) delete mode 100644 apis/management.cattle.io/v3/zz_generated_cluster_compose_config_controller.go delete mode 100644 apis/management.cattle.io/v3/zz_generated_cluster_compose_config_lifecycle_adapter.go create mode 100644 apis/management.cattle.io/v3/zz_generated_compose_config_controller.go create mode 100644 apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go delete mode 100644 apis/management.cattle.io/v3/zz_generated_global_compose_config_controller.go delete mode 100644 apis/management.cattle.io/v3/zz_generated_global_compose_config_lifecycle_adapter.go delete mode 100644 apis/project.cattle.io/v3/zz_generated_namespace_compose_config_controller.go delete mode 100644 apis/project.cattle.io/v3/zz_generated_namespace_compose_config_lifecycle_adapter.go delete mode 100644 client/management/v3/zz_generated_cluster_compose_config.go delete mode 100644 client/management/v3/zz_generated_cluster_compose_spec.go create mode 100644 client/management/v3/zz_generated_compose_config.go delete mode 100644 client/management/v3/zz_generated_global_compose_config.go delete mode 100644 client/project/v3/zz_generated_compose_condition.go delete mode 100644 client/project/v3/zz_generated_compose_status.go delete mode 100644 client/project/v3/zz_generated_namespace_compose_config.go delete mode 100644 client/project/v3/zz_generated_namespace_compose_spec.go diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_compose_config_controller.go b/apis/management.cattle.io/v3/zz_generated_cluster_compose_config_controller.go deleted file mode 100644 index 3d333218..00000000 --- a/apis/management.cattle.io/v3/zz_generated_cluster_compose_config_controller.go +++ /dev/null @@ -1,252 +0,0 @@ -package v3 - -import ( - "context" - - "github.com/rancher/norman/controller" - "github.com/rancher/norman/objectclient" - "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 ( - ClusterComposeConfigGroupVersionKind = schema.GroupVersionKind{ - Version: Version, - Group: GroupName, - Kind: "ClusterComposeConfig", - } - ClusterComposeConfigResource = metav1.APIResource{ - Name: "clustercomposeconfigs", - SingularName: "clustercomposeconfig", - Namespaced: true, - - Kind: ClusterComposeConfigGroupVersionKind.Kind, - } -) - -type ClusterComposeConfigList struct { - metav1.TypeMeta `json:",inline"` - metav1.ListMeta `json:"metadata,omitempty"` - Items []ClusterComposeConfig -} - -type ClusterComposeConfigHandlerFunc func(key string, obj *ClusterComposeConfig) error - -type ClusterComposeConfigLister interface { - List(namespace string, selector labels.Selector) (ret []*ClusterComposeConfig, err error) - Get(namespace, name string) (*ClusterComposeConfig, error) -} - -type ClusterComposeConfigController interface { - Informer() cache.SharedIndexInformer - Lister() ClusterComposeConfigLister - AddHandler(name string, handler ClusterComposeConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler ClusterComposeConfigHandlerFunc) - Enqueue(namespace, name string) - Sync(ctx context.Context) error - Start(ctx context.Context, threadiness int) error -} - -type ClusterComposeConfigInterface interface { - ObjectClient() *objectclient.ObjectClient - Create(*ClusterComposeConfig) (*ClusterComposeConfig, error) - GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterComposeConfig, error) - Get(name string, opts metav1.GetOptions) (*ClusterComposeConfig, error) - Update(*ClusterComposeConfig) (*ClusterComposeConfig, error) - Delete(name string, options *metav1.DeleteOptions) error - DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error - List(opts metav1.ListOptions) (*ClusterComposeConfigList, error) - Watch(opts metav1.ListOptions) (watch.Interface, error) - DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error - Controller() ClusterComposeConfigController - AddHandler(name string, sync ClusterComposeConfigHandlerFunc) - AddLifecycle(name string, lifecycle ClusterComposeConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync ClusterComposeConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterComposeConfigLifecycle) -} - -type clusterComposeConfigLister struct { - controller *clusterComposeConfigController -} - -func (l *clusterComposeConfigLister) List(namespace string, selector labels.Selector) (ret []*ClusterComposeConfig, err error) { - err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { - ret = append(ret, obj.(*ClusterComposeConfig)) - }) - return -} - -func (l *clusterComposeConfigLister) Get(namespace, name string) (*ClusterComposeConfig, 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: ClusterComposeConfigGroupVersionKind.Group, - Resource: "clusterComposeConfig", - }, name) - } - return obj.(*ClusterComposeConfig), nil -} - -type clusterComposeConfigController struct { - controller.GenericController -} - -func (c *clusterComposeConfigController) Lister() ClusterComposeConfigLister { - return &clusterComposeConfigLister{ - controller: c, - } -} - -func (c *clusterComposeConfigController) AddHandler(name string, handler ClusterComposeConfigHandlerFunc) { - 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.(*ClusterComposeConfig)) - }) -} - -func (c *clusterComposeConfigController) AddClusterScopedHandler(name, cluster string, handler ClusterComposeConfigHandlerFunc) { - 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.(*ClusterComposeConfig)) - }) -} - -type clusterComposeConfigFactory struct { -} - -func (c clusterComposeConfigFactory) Object() runtime.Object { - return &ClusterComposeConfig{} -} - -func (c clusterComposeConfigFactory) List() runtime.Object { - return &ClusterComposeConfigList{} -} - -func (s *clusterComposeConfigClient) Controller() ClusterComposeConfigController { - s.client.Lock() - defer s.client.Unlock() - - c, ok := s.client.clusterComposeConfigControllers[s.ns] - if ok { - return c - } - - genericController := controller.NewGenericController(ClusterComposeConfigGroupVersionKind.Kind+"Controller", - s.objectClient) - - c = &clusterComposeConfigController{ - GenericController: genericController, - } - - s.client.clusterComposeConfigControllers[s.ns] = c - s.client.starters = append(s.client.starters, c) - - return c -} - -type clusterComposeConfigClient struct { - client *Client - ns string - objectClient *objectclient.ObjectClient - controller ClusterComposeConfigController -} - -func (s *clusterComposeConfigClient) ObjectClient() *objectclient.ObjectClient { - return s.objectClient -} - -func (s *clusterComposeConfigClient) Create(o *ClusterComposeConfig) (*ClusterComposeConfig, error) { - obj, err := s.objectClient.Create(o) - return obj.(*ClusterComposeConfig), err -} - -func (s *clusterComposeConfigClient) Get(name string, opts metav1.GetOptions) (*ClusterComposeConfig, error) { - obj, err := s.objectClient.Get(name, opts) - return obj.(*ClusterComposeConfig), err -} - -func (s *clusterComposeConfigClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ClusterComposeConfig, error) { - obj, err := s.objectClient.GetNamespaced(namespace, name, opts) - return obj.(*ClusterComposeConfig), err -} - -func (s *clusterComposeConfigClient) Update(o *ClusterComposeConfig) (*ClusterComposeConfig, error) { - obj, err := s.objectClient.Update(o.Name, o) - return obj.(*ClusterComposeConfig), err -} - -func (s *clusterComposeConfigClient) Delete(name string, options *metav1.DeleteOptions) error { - return s.objectClient.Delete(name, options) -} - -func (s *clusterComposeConfigClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { - return s.objectClient.DeleteNamespaced(namespace, name, options) -} - -func (s *clusterComposeConfigClient) List(opts metav1.ListOptions) (*ClusterComposeConfigList, error) { - obj, err := s.objectClient.List(opts) - return obj.(*ClusterComposeConfigList), err -} - -func (s *clusterComposeConfigClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { - return s.objectClient.Watch(opts) -} - -// Patch applies the patch and returns the patched deployment. -func (s *clusterComposeConfigClient) Patch(o *ClusterComposeConfig, data []byte, subresources ...string) (*ClusterComposeConfig, error) { - obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) - return obj.(*ClusterComposeConfig), err -} - -func (s *clusterComposeConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { - return s.objectClient.DeleteCollection(deleteOpts, listOpts) -} - -func (s *clusterComposeConfigClient) AddHandler(name string, sync ClusterComposeConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) -} - -func (s *clusterComposeConfigClient) AddLifecycle(name string, lifecycle ClusterComposeConfigLifecycle) { - sync := NewClusterComposeConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) -} - -func (s *clusterComposeConfigClient) AddClusterScopedHandler(name, clusterName string, sync ClusterComposeConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) -} - -func (s *clusterComposeConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ClusterComposeConfigLifecycle) { - sync := NewClusterComposeConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) -} diff --git a/apis/management.cattle.io/v3/zz_generated_cluster_compose_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_cluster_compose_config_lifecycle_adapter.go deleted file mode 100644 index 457d39d0..00000000 --- a/apis/management.cattle.io/v3/zz_generated_cluster_compose_config_lifecycle_adapter.go +++ /dev/null @@ -1,51 +0,0 @@ -package v3 - -import ( - "github.com/rancher/norman/lifecycle" - "k8s.io/apimachinery/pkg/runtime" -) - -type ClusterComposeConfigLifecycle interface { - Create(obj *ClusterComposeConfig) (*ClusterComposeConfig, error) - Remove(obj *ClusterComposeConfig) (*ClusterComposeConfig, error) - Updated(obj *ClusterComposeConfig) (*ClusterComposeConfig, error) -} - -type clusterComposeConfigLifecycleAdapter struct { - lifecycle ClusterComposeConfigLifecycle -} - -func (w *clusterComposeConfigLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Create(obj.(*ClusterComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func (w *clusterComposeConfigLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Remove(obj.(*ClusterComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func (w *clusterComposeConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Updated(obj.(*ClusterComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func NewClusterComposeConfigLifecycleAdapter(name string, clusterScoped bool, client ClusterComposeConfigInterface, l ClusterComposeConfigLifecycle) ClusterComposeConfigHandlerFunc { - adapter := &clusterComposeConfigLifecycleAdapter{lifecycle: l} - syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *ClusterComposeConfig) error { - if obj == nil { - return syncFn(key, nil) - } - return syncFn(key, obj) - } -} diff --git a/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go b/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go new file mode 100644 index 00000000..c32cf747 --- /dev/null +++ b/apis/management.cattle.io/v3/zz_generated_compose_config_controller.go @@ -0,0 +1,251 @@ +package v3 + +import ( + "context" + + "github.com/rancher/norman/controller" + "github.com/rancher/norman/objectclient" + "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 ( + ComposeConfigGroupVersionKind = schema.GroupVersionKind{ + Version: Version, + Group: GroupName, + Kind: "ComposeConfig", + } + ComposeConfigResource = metav1.APIResource{ + Name: "composeconfigs", + SingularName: "composeconfig", + Namespaced: false, + Kind: ComposeConfigGroupVersionKind.Kind, + } +) + +type ComposeConfigList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []ComposeConfig +} + +type ComposeConfigHandlerFunc func(key string, obj *ComposeConfig) error + +type ComposeConfigLister interface { + List(namespace string, selector labels.Selector) (ret []*ComposeConfig, err error) + Get(namespace, name string) (*ComposeConfig, error) +} + +type ComposeConfigController interface { + Informer() cache.SharedIndexInformer + Lister() ComposeConfigLister + AddHandler(name string, handler ComposeConfigHandlerFunc) + AddClusterScopedHandler(name, clusterName string, handler ComposeConfigHandlerFunc) + Enqueue(namespace, name string) + Sync(ctx context.Context) error + Start(ctx context.Context, threadiness int) error +} + +type ComposeConfigInterface interface { + ObjectClient() *objectclient.ObjectClient + Create(*ComposeConfig) (*ComposeConfig, error) + GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ComposeConfig, error) + Get(name string, opts metav1.GetOptions) (*ComposeConfig, error) + Update(*ComposeConfig) (*ComposeConfig, error) + Delete(name string, options *metav1.DeleteOptions) error + DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error + List(opts metav1.ListOptions) (*ComposeConfigList, error) + Watch(opts metav1.ListOptions) (watch.Interface, error) + DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error + Controller() ComposeConfigController + AddHandler(name string, sync ComposeConfigHandlerFunc) + AddLifecycle(name string, lifecycle ComposeConfigLifecycle) + AddClusterScopedHandler(name, clusterName string, sync ComposeConfigHandlerFunc) + AddClusterScopedLifecycle(name, clusterName string, lifecycle ComposeConfigLifecycle) +} + +type composeConfigLister struct { + controller *composeConfigController +} + +func (l *composeConfigLister) List(namespace string, selector labels.Selector) (ret []*ComposeConfig, err error) { + err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { + ret = append(ret, obj.(*ComposeConfig)) + }) + return +} + +func (l *composeConfigLister) Get(namespace, name string) (*ComposeConfig, 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: ComposeConfigGroupVersionKind.Group, + Resource: "composeConfig", + }, name) + } + return obj.(*ComposeConfig), nil +} + +type composeConfigController struct { + controller.GenericController +} + +func (c *composeConfigController) Lister() ComposeConfigLister { + return &composeConfigLister{ + controller: c, + } +} + +func (c *composeConfigController) AddHandler(name string, handler ComposeConfigHandlerFunc) { + 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.(*ComposeConfig)) + }) +} + +func (c *composeConfigController) AddClusterScopedHandler(name, cluster string, handler ComposeConfigHandlerFunc) { + 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.(*ComposeConfig)) + }) +} + +type composeConfigFactory struct { +} + +func (c composeConfigFactory) Object() runtime.Object { + return &ComposeConfig{} +} + +func (c composeConfigFactory) List() runtime.Object { + return &ComposeConfigList{} +} + +func (s *composeConfigClient) Controller() ComposeConfigController { + s.client.Lock() + defer s.client.Unlock() + + c, ok := s.client.composeConfigControllers[s.ns] + if ok { + return c + } + + genericController := controller.NewGenericController(ComposeConfigGroupVersionKind.Kind+"Controller", + s.objectClient) + + c = &composeConfigController{ + GenericController: genericController, + } + + s.client.composeConfigControllers[s.ns] = c + s.client.starters = append(s.client.starters, c) + + return c +} + +type composeConfigClient struct { + client *Client + ns string + objectClient *objectclient.ObjectClient + controller ComposeConfigController +} + +func (s *composeConfigClient) ObjectClient() *objectclient.ObjectClient { + return s.objectClient +} + +func (s *composeConfigClient) Create(o *ComposeConfig) (*ComposeConfig, error) { + obj, err := s.objectClient.Create(o) + return obj.(*ComposeConfig), err +} + +func (s *composeConfigClient) Get(name string, opts metav1.GetOptions) (*ComposeConfig, error) { + obj, err := s.objectClient.Get(name, opts) + return obj.(*ComposeConfig), err +} + +func (s *composeConfigClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*ComposeConfig, error) { + obj, err := s.objectClient.GetNamespaced(namespace, name, opts) + return obj.(*ComposeConfig), err +} + +func (s *composeConfigClient) Update(o *ComposeConfig) (*ComposeConfig, error) { + obj, err := s.objectClient.Update(o.Name, o) + return obj.(*ComposeConfig), err +} + +func (s *composeConfigClient) Delete(name string, options *metav1.DeleteOptions) error { + return s.objectClient.Delete(name, options) +} + +func (s *composeConfigClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { + return s.objectClient.DeleteNamespaced(namespace, name, options) +} + +func (s *composeConfigClient) List(opts metav1.ListOptions) (*ComposeConfigList, error) { + obj, err := s.objectClient.List(opts) + return obj.(*ComposeConfigList), err +} + +func (s *composeConfigClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { + return s.objectClient.Watch(opts) +} + +// Patch applies the patch and returns the patched deployment. +func (s *composeConfigClient) Patch(o *ComposeConfig, data []byte, subresources ...string) (*ComposeConfig, error) { + obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) + return obj.(*ComposeConfig), err +} + +func (s *composeConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { + return s.objectClient.DeleteCollection(deleteOpts, listOpts) +} + +func (s *composeConfigClient) AddHandler(name string, sync ComposeConfigHandlerFunc) { + s.Controller().AddHandler(name, sync) +} + +func (s *composeConfigClient) AddLifecycle(name string, lifecycle ComposeConfigLifecycle) { + sync := NewComposeConfigLifecycleAdapter(name, false, s, lifecycle) + s.AddHandler(name, sync) +} + +func (s *composeConfigClient) AddClusterScopedHandler(name, clusterName string, sync ComposeConfigHandlerFunc) { + s.Controller().AddClusterScopedHandler(name, clusterName, sync) +} + +func (s *composeConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle ComposeConfigLifecycle) { + sync := NewComposeConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) + s.AddClusterScopedHandler(name, clusterName, sync) +} diff --git a/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go new file mode 100644 index 00000000..96a5ea75 --- /dev/null +++ b/apis/management.cattle.io/v3/zz_generated_compose_config_lifecycle_adapter.go @@ -0,0 +1,51 @@ +package v3 + +import ( + "github.com/rancher/norman/lifecycle" + "k8s.io/apimachinery/pkg/runtime" +) + +type ComposeConfigLifecycle interface { + Create(obj *ComposeConfig) (*ComposeConfig, error) + Remove(obj *ComposeConfig) (*ComposeConfig, error) + Updated(obj *ComposeConfig) (*ComposeConfig, error) +} + +type composeConfigLifecycleAdapter struct { + lifecycle ComposeConfigLifecycle +} + +func (w *composeConfigLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Create(obj.(*ComposeConfig)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *composeConfigLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Remove(obj.(*ComposeConfig)) + if o == nil { + return nil, err + } + return o, err +} + +func (w *composeConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { + o, err := w.lifecycle.Updated(obj.(*ComposeConfig)) + if o == nil { + return nil, err + } + return o, err +} + +func NewComposeConfigLifecycleAdapter(name string, clusterScoped bool, client ComposeConfigInterface, l ComposeConfigLifecycle) ComposeConfigHandlerFunc { + adapter := &composeConfigLifecycleAdapter{lifecycle: l} + syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) + return func(key string, obj *ComposeConfig) error { + if obj == nil { + return syncFn(key, nil) + } + return syncFn(key, obj) + } +} diff --git a/apis/management.cattle.io/v3/zz_generated_deepcopy.go b/apis/management.cattle.io/v3/zz_generated_deepcopy.go index 5da283f5..7a2c0e46 100644 --- a/apis/management.cattle.io/v3/zz_generated_deepcopy.go +++ b/apis/management.cattle.io/v3/zz_generated_deepcopy.go @@ -148,18 +148,6 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*ClusterComponentStatus).DeepCopyInto(out.(*ClusterComponentStatus)) return nil }, InType: reflect.TypeOf(&ClusterComponentStatus{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*ClusterComposeConfig).DeepCopyInto(out.(*ClusterComposeConfig)) - return nil - }, InType: reflect.TypeOf(&ClusterComposeConfig{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*ClusterComposeConfigList).DeepCopyInto(out.(*ClusterComposeConfigList)) - return nil - }, InType: reflect.TypeOf(&ClusterComposeConfigList{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*ClusterComposeSpec).DeepCopyInto(out.(*ClusterComposeSpec)) - return nil - }, InType: reflect.TypeOf(&ClusterComposeSpec{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*ClusterCondition).DeepCopyInto(out.(*ClusterCondition)) return nil @@ -244,6 +232,14 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*ComposeCondition).DeepCopyInto(out.(*ComposeCondition)) return nil }, InType: reflect.TypeOf(&ComposeCondition{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ComposeConfig).DeepCopyInto(out.(*ComposeConfig)) + return nil + }, InType: reflect.TypeOf(&ComposeConfig{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ComposeConfigList).DeepCopyInto(out.(*ComposeConfigList)) + return nil + }, InType: reflect.TypeOf(&ComposeConfigList{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*ComposeSpec).DeepCopyInto(out.(*ComposeSpec)) return nil @@ -292,6 +288,10 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*EmbeddedConfig).DeepCopyInto(out.(*EmbeddedConfig)) return nil }, InType: reflect.TypeOf(&EmbeddedConfig{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ExportOutput).DeepCopyInto(out.(*ExportOutput)) + return nil + }, InType: reflect.TypeOf(&ExportOutput{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*Field).DeepCopyInto(out.(*Field)) return nil @@ -328,14 +328,6 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*GithubConfigTestOutput).DeepCopyInto(out.(*GithubConfigTestOutput)) return nil }, InType: reflect.TypeOf(&GithubConfigTestOutput{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*GlobalComposeConfig).DeepCopyInto(out.(*GlobalComposeConfig)) - return nil - }, InType: reflect.TypeOf(&GlobalComposeConfig{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*GlobalComposeConfigList).DeepCopyInto(out.(*GlobalComposeConfigList)) - return nil - }, InType: reflect.TypeOf(&GlobalComposeConfigList{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*GlobalRole).DeepCopyInto(out.(*GlobalRole)) return nil @@ -1717,86 +1709,6 @@ func (in *ClusterComponentStatus) DeepCopy() *ClusterComponentStatus { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *ClusterComposeConfig) DeepCopyInto(out *ClusterComposeConfig) { - *out = *in - out.Namespaced = in.Namespaced - out.TypeMeta = in.TypeMeta - in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) - out.Spec = in.Spec - in.Status.DeepCopyInto(&out.Status) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterComposeConfig. -func (in *ClusterComposeConfig) DeepCopy() *ClusterComposeConfig { - if in == nil { - return nil - } - out := new(ClusterComposeConfig) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. -func (in *ClusterComposeConfig) 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 *ClusterComposeConfigList) DeepCopyInto(out *ClusterComposeConfigList) { - *out = *in - out.TypeMeta = in.TypeMeta - out.ListMeta = in.ListMeta - if in.Items != nil { - in, out := &in.Items, &out.Items - *out = make([]ClusterComposeConfig, len(*in)) - for i := range *in { - (*in)[i].DeepCopyInto(&(*out)[i]) - } - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterComposeConfigList. -func (in *ClusterComposeConfigList) DeepCopy() *ClusterComposeConfigList { - if in == nil { - return nil - } - out := new(ClusterComposeConfigList) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. -func (in *ClusterComposeConfigList) 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 *ClusterComposeSpec) DeepCopyInto(out *ClusterComposeSpec) { - *out = *in - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterComposeSpec. -func (in *ClusterComposeSpec) DeepCopy() *ClusterComposeSpec { - if in == nil { - return nil - } - out := new(ClusterComposeSpec) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ClusterCondition) DeepCopyInto(out *ClusterCondition) { *out = *in @@ -2444,6 +2356,69 @@ func (in *ComposeCondition) DeepCopy() *ComposeCondition { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ComposeConfig) DeepCopyInto(out *ComposeConfig) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + out.Spec = in.Spec + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeConfig. +func (in *ComposeConfig) DeepCopy() *ComposeConfig { + if in == nil { + return nil + } + out := new(ComposeConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ComposeConfig) 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 *ComposeConfigList) DeepCopyInto(out *ComposeConfigList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ComposeConfig, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeConfigList. +func (in *ComposeConfigList) DeepCopy() *ComposeConfigList { + if in == nil { + return nil + } + out := new(ComposeConfigList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ComposeConfigList) 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 *ComposeSpec) DeepCopyInto(out *ComposeSpec) { *out = *in @@ -2733,6 +2708,22 @@ func (in *EmbeddedConfig) DeepCopy() *EmbeddedConfig { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExportOutput) DeepCopyInto(out *ExportOutput) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExportOutput. +func (in *ExportOutput) DeepCopy() *ExportOutput { + if in == nil { + return nil + } + out := new(ExportOutput) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Field) DeepCopyInto(out *Field) { *out = *in @@ -2901,69 +2892,6 @@ func (in *GithubConfigTestOutput) DeepCopy() *GithubConfigTestOutput { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *GlobalComposeConfig) DeepCopyInto(out *GlobalComposeConfig) { - *out = *in - out.TypeMeta = in.TypeMeta - in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) - out.Spec = in.Spec - in.Status.DeepCopyInto(&out.Status) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalComposeConfig. -func (in *GlobalComposeConfig) DeepCopy() *GlobalComposeConfig { - if in == nil { - return nil - } - out := new(GlobalComposeConfig) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. -func (in *GlobalComposeConfig) 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 *GlobalComposeConfigList) DeepCopyInto(out *GlobalComposeConfigList) { - *out = *in - out.TypeMeta = in.TypeMeta - out.ListMeta = in.ListMeta - if in.Items != nil { - in, out := &in.Items, &out.Items - *out = make([]GlobalComposeConfig, len(*in)) - for i := range *in { - (*in)[i].DeepCopyInto(&(*out)[i]) - } - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlobalComposeConfigList. -func (in *GlobalComposeConfigList) DeepCopy() *GlobalComposeConfigList { - if in == nil { - return nil - } - out := new(GlobalComposeConfigList) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. -func (in *GlobalComposeConfigList) 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 *GlobalRole) DeepCopyInto(out *GlobalRole) { *out = *in diff --git a/apis/management.cattle.io/v3/zz_generated_global_compose_config_controller.go b/apis/management.cattle.io/v3/zz_generated_global_compose_config_controller.go deleted file mode 100644 index 5a50d28b..00000000 --- a/apis/management.cattle.io/v3/zz_generated_global_compose_config_controller.go +++ /dev/null @@ -1,251 +0,0 @@ -package v3 - -import ( - "context" - - "github.com/rancher/norman/controller" - "github.com/rancher/norman/objectclient" - "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 ( - GlobalComposeConfigGroupVersionKind = schema.GroupVersionKind{ - Version: Version, - Group: GroupName, - Kind: "GlobalComposeConfig", - } - GlobalComposeConfigResource = metav1.APIResource{ - Name: "globalcomposeconfigs", - SingularName: "globalcomposeconfig", - Namespaced: false, - Kind: GlobalComposeConfigGroupVersionKind.Kind, - } -) - -type GlobalComposeConfigList struct { - metav1.TypeMeta `json:",inline"` - metav1.ListMeta `json:"metadata,omitempty"` - Items []GlobalComposeConfig -} - -type GlobalComposeConfigHandlerFunc func(key string, obj *GlobalComposeConfig) error - -type GlobalComposeConfigLister interface { - List(namespace string, selector labels.Selector) (ret []*GlobalComposeConfig, err error) - Get(namespace, name string) (*GlobalComposeConfig, error) -} - -type GlobalComposeConfigController interface { - Informer() cache.SharedIndexInformer - Lister() GlobalComposeConfigLister - AddHandler(name string, handler GlobalComposeConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler GlobalComposeConfigHandlerFunc) - Enqueue(namespace, name string) - Sync(ctx context.Context) error - Start(ctx context.Context, threadiness int) error -} - -type GlobalComposeConfigInterface interface { - ObjectClient() *objectclient.ObjectClient - Create(*GlobalComposeConfig) (*GlobalComposeConfig, error) - GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GlobalComposeConfig, error) - Get(name string, opts metav1.GetOptions) (*GlobalComposeConfig, error) - Update(*GlobalComposeConfig) (*GlobalComposeConfig, error) - Delete(name string, options *metav1.DeleteOptions) error - DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error - List(opts metav1.ListOptions) (*GlobalComposeConfigList, error) - Watch(opts metav1.ListOptions) (watch.Interface, error) - DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error - Controller() GlobalComposeConfigController - AddHandler(name string, sync GlobalComposeConfigHandlerFunc) - AddLifecycle(name string, lifecycle GlobalComposeConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync GlobalComposeConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle GlobalComposeConfigLifecycle) -} - -type globalComposeConfigLister struct { - controller *globalComposeConfigController -} - -func (l *globalComposeConfigLister) List(namespace string, selector labels.Selector) (ret []*GlobalComposeConfig, err error) { - err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { - ret = append(ret, obj.(*GlobalComposeConfig)) - }) - return -} - -func (l *globalComposeConfigLister) Get(namespace, name string) (*GlobalComposeConfig, 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: GlobalComposeConfigGroupVersionKind.Group, - Resource: "globalComposeConfig", - }, name) - } - return obj.(*GlobalComposeConfig), nil -} - -type globalComposeConfigController struct { - controller.GenericController -} - -func (c *globalComposeConfigController) Lister() GlobalComposeConfigLister { - return &globalComposeConfigLister{ - controller: c, - } -} - -func (c *globalComposeConfigController) AddHandler(name string, handler GlobalComposeConfigHandlerFunc) { - 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.(*GlobalComposeConfig)) - }) -} - -func (c *globalComposeConfigController) AddClusterScopedHandler(name, cluster string, handler GlobalComposeConfigHandlerFunc) { - 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.(*GlobalComposeConfig)) - }) -} - -type globalComposeConfigFactory struct { -} - -func (c globalComposeConfigFactory) Object() runtime.Object { - return &GlobalComposeConfig{} -} - -func (c globalComposeConfigFactory) List() runtime.Object { - return &GlobalComposeConfigList{} -} - -func (s *globalComposeConfigClient) Controller() GlobalComposeConfigController { - s.client.Lock() - defer s.client.Unlock() - - c, ok := s.client.globalComposeConfigControllers[s.ns] - if ok { - return c - } - - genericController := controller.NewGenericController(GlobalComposeConfigGroupVersionKind.Kind+"Controller", - s.objectClient) - - c = &globalComposeConfigController{ - GenericController: genericController, - } - - s.client.globalComposeConfigControllers[s.ns] = c - s.client.starters = append(s.client.starters, c) - - return c -} - -type globalComposeConfigClient struct { - client *Client - ns string - objectClient *objectclient.ObjectClient - controller GlobalComposeConfigController -} - -func (s *globalComposeConfigClient) ObjectClient() *objectclient.ObjectClient { - return s.objectClient -} - -func (s *globalComposeConfigClient) Create(o *GlobalComposeConfig) (*GlobalComposeConfig, error) { - obj, err := s.objectClient.Create(o) - return obj.(*GlobalComposeConfig), err -} - -func (s *globalComposeConfigClient) Get(name string, opts metav1.GetOptions) (*GlobalComposeConfig, error) { - obj, err := s.objectClient.Get(name, opts) - return obj.(*GlobalComposeConfig), err -} - -func (s *globalComposeConfigClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*GlobalComposeConfig, error) { - obj, err := s.objectClient.GetNamespaced(namespace, name, opts) - return obj.(*GlobalComposeConfig), err -} - -func (s *globalComposeConfigClient) Update(o *GlobalComposeConfig) (*GlobalComposeConfig, error) { - obj, err := s.objectClient.Update(o.Name, o) - return obj.(*GlobalComposeConfig), err -} - -func (s *globalComposeConfigClient) Delete(name string, options *metav1.DeleteOptions) error { - return s.objectClient.Delete(name, options) -} - -func (s *globalComposeConfigClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { - return s.objectClient.DeleteNamespaced(namespace, name, options) -} - -func (s *globalComposeConfigClient) List(opts metav1.ListOptions) (*GlobalComposeConfigList, error) { - obj, err := s.objectClient.List(opts) - return obj.(*GlobalComposeConfigList), err -} - -func (s *globalComposeConfigClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { - return s.objectClient.Watch(opts) -} - -// Patch applies the patch and returns the patched deployment. -func (s *globalComposeConfigClient) Patch(o *GlobalComposeConfig, data []byte, subresources ...string) (*GlobalComposeConfig, error) { - obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) - return obj.(*GlobalComposeConfig), err -} - -func (s *globalComposeConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { - return s.objectClient.DeleteCollection(deleteOpts, listOpts) -} - -func (s *globalComposeConfigClient) AddHandler(name string, sync GlobalComposeConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) -} - -func (s *globalComposeConfigClient) AddLifecycle(name string, lifecycle GlobalComposeConfigLifecycle) { - sync := NewGlobalComposeConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) -} - -func (s *globalComposeConfigClient) AddClusterScopedHandler(name, clusterName string, sync GlobalComposeConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) -} - -func (s *globalComposeConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle GlobalComposeConfigLifecycle) { - sync := NewGlobalComposeConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) -} diff --git a/apis/management.cattle.io/v3/zz_generated_global_compose_config_lifecycle_adapter.go b/apis/management.cattle.io/v3/zz_generated_global_compose_config_lifecycle_adapter.go deleted file mode 100644 index 586710ff..00000000 --- a/apis/management.cattle.io/v3/zz_generated_global_compose_config_lifecycle_adapter.go +++ /dev/null @@ -1,51 +0,0 @@ -package v3 - -import ( - "github.com/rancher/norman/lifecycle" - "k8s.io/apimachinery/pkg/runtime" -) - -type GlobalComposeConfigLifecycle interface { - Create(obj *GlobalComposeConfig) (*GlobalComposeConfig, error) - Remove(obj *GlobalComposeConfig) (*GlobalComposeConfig, error) - Updated(obj *GlobalComposeConfig) (*GlobalComposeConfig, error) -} - -type globalComposeConfigLifecycleAdapter struct { - lifecycle GlobalComposeConfigLifecycle -} - -func (w *globalComposeConfigLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Create(obj.(*GlobalComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func (w *globalComposeConfigLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Remove(obj.(*GlobalComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func (w *globalComposeConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Updated(obj.(*GlobalComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func NewGlobalComposeConfigLifecycleAdapter(name string, clusterScoped bool, client GlobalComposeConfigInterface, l GlobalComposeConfigLifecycle) GlobalComposeConfigHandlerFunc { - adapter := &globalComposeConfigLifecycleAdapter{lifecycle: l} - syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *GlobalComposeConfig) error { - if obj == nil { - return syncFn(key, nil) - } - return syncFn(key, obj) - } -} diff --git a/apis/management.cattle.io/v3/zz_generated_k8s_client.go b/apis/management.cattle.io/v3/zz_generated_k8s_client.go index be177c7f..da2e5f23 100644 --- a/apis/management.cattle.io/v3/zz_generated_k8s_client.go +++ b/apis/management.cattle.io/v3/zz_generated_k8s_client.go @@ -56,8 +56,7 @@ type Interface interface { PipelineExecutionsGetter PipelineExecutionLogsGetter SourceCodeRepositoriesGetter - GlobalComposeConfigsGetter - ClusterComposeConfigsGetter + ComposeConfigsGetter } type Client struct { @@ -106,8 +105,7 @@ type Client struct { pipelineExecutionControllers map[string]PipelineExecutionController pipelineExecutionLogControllers map[string]PipelineExecutionLogController sourceCodeRepositoryControllers map[string]SourceCodeRepositoryController - globalComposeConfigControllers map[string]GlobalComposeConfigController - clusterComposeConfigControllers map[string]ClusterComposeConfigController + composeConfigControllers map[string]ComposeConfigController } func NewForConfig(config rest.Config) (Interface, error) { @@ -165,8 +163,7 @@ func NewForConfig(config rest.Config) (Interface, error) { pipelineExecutionControllers: map[string]PipelineExecutionController{}, pipelineExecutionLogControllers: map[string]PipelineExecutionLogController{}, sourceCodeRepositoryControllers: map[string]SourceCodeRepositoryController{}, - globalComposeConfigControllers: map[string]GlobalComposeConfigController{}, - clusterComposeConfigControllers: map[string]ClusterComposeConfigController{}, + composeConfigControllers: map[string]ComposeConfigController{}, }, nil } @@ -715,26 +712,13 @@ func (c *Client) SourceCodeRepositories(namespace string) SourceCodeRepositoryIn } } -type GlobalComposeConfigsGetter interface { - GlobalComposeConfigs(namespace string) GlobalComposeConfigInterface +type ComposeConfigsGetter interface { + ComposeConfigs(namespace string) ComposeConfigInterface } -func (c *Client) GlobalComposeConfigs(namespace string) GlobalComposeConfigInterface { - objectClient := objectclient.NewObjectClient(namespace, c.restClient, &GlobalComposeConfigResource, GlobalComposeConfigGroupVersionKind, globalComposeConfigFactory{}) - return &globalComposeConfigClient{ - ns: namespace, - client: c, - objectClient: objectClient, - } -} - -type ClusterComposeConfigsGetter interface { - ClusterComposeConfigs(namespace string) ClusterComposeConfigInterface -} - -func (c *Client) ClusterComposeConfigs(namespace string) ClusterComposeConfigInterface { - objectClient := objectclient.NewObjectClient(namespace, c.restClient, &ClusterComposeConfigResource, ClusterComposeConfigGroupVersionKind, clusterComposeConfigFactory{}) - return &clusterComposeConfigClient{ +func (c *Client) ComposeConfigs(namespace string) ComposeConfigInterface { + objectClient := objectclient.NewObjectClient(namespace, c.restClient, &ComposeConfigResource, ComposeConfigGroupVersionKind, composeConfigFactory{}) + return &composeConfigClient{ ns: namespace, client: c, objectClient: objectClient, diff --git a/apis/management.cattle.io/v3/zz_generated_scheme.go b/apis/management.cattle.io/v3/zz_generated_scheme.go index ab90db86..26ccca06 100644 --- a/apis/management.cattle.io/v3/zz_generated_scheme.go +++ b/apis/management.cattle.io/v3/zz_generated_scheme.go @@ -115,10 +115,8 @@ func addKnownTypes(scheme *runtime.Scheme) error { &PipelineExecutionLogList{}, &SourceCodeRepository{}, &SourceCodeRepositoryList{}, - &GlobalComposeConfig{}, - &GlobalComposeConfigList{}, - &ClusterComposeConfig{}, - &ClusterComposeConfigList{}, + &ComposeConfig{}, + &ComposeConfigList{}, ) return nil } diff --git a/apis/project.cattle.io/v3/zz_generated_deepcopy.go b/apis/project.cattle.io/v3/zz_generated_deepcopy.go index 02f3be75..15e8b50e 100644 --- a/apis/project.cattle.io/v3/zz_generated_deepcopy.go +++ b/apis/project.cattle.io/v3/zz_generated_deepcopy.go @@ -73,14 +73,6 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*CertificateList).DeepCopyInto(out.(*CertificateList)) return nil }, InType: reflect.TypeOf(&CertificateList{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*ComposeCondition).DeepCopyInto(out.(*ComposeCondition)) - return nil - }, InType: reflect.TypeOf(&ComposeCondition{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*ComposeStatus).DeepCopyInto(out.(*ComposeStatus)) - return nil - }, InType: reflect.TypeOf(&ComposeStatus{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*DeploymentRollbackInput).DeepCopyInto(out.(*DeploymentRollbackInput)) return nil @@ -93,18 +85,6 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*DockerCredentialList).DeepCopyInto(out.(*DockerCredentialList)) return nil }, InType: reflect.TypeOf(&DockerCredentialList{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*NamespaceComposeConfig).DeepCopyInto(out.(*NamespaceComposeConfig)) - return nil - }, InType: reflect.TypeOf(&NamespaceComposeConfig{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*NamespaceComposeConfigList).DeepCopyInto(out.(*NamespaceComposeConfigList)) - return nil - }, InType: reflect.TypeOf(&NamespaceComposeConfigList{})}, - conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { - in.(*NamespaceComposeSpec).DeepCopyInto(out.(*NamespaceComposeSpec)) - return nil - }, InType: reflect.TypeOf(&NamespaceComposeSpec{})}, conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { in.(*NamespacedBasicAuth).DeepCopyInto(out.(*NamespacedBasicAuth)) return nil @@ -577,43 +557,6 @@ func (in *CertificateList) DeepCopyObject() runtime.Object { } } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *ComposeCondition) DeepCopyInto(out *ComposeCondition) { - *out = *in - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeCondition. -func (in *ComposeCondition) DeepCopy() *ComposeCondition { - if in == nil { - return nil - } - out := new(ComposeCondition) - in.DeepCopyInto(out) - return out -} - -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *ComposeStatus) DeepCopyInto(out *ComposeStatus) { - *out = *in - if in.Conditions != nil { - in, out := &in.Conditions, &out.Conditions - *out = make([]ComposeCondition, len(*in)) - copy(*out, *in) - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComposeStatus. -func (in *ComposeStatus) DeepCopy() *ComposeStatus { - if in == nil { - return nil - } - out := new(ComposeStatus) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DeploymentRollbackInput) DeepCopyInto(out *DeploymentRollbackInput) { *out = *in @@ -699,86 +642,6 @@ func (in *DockerCredentialList) DeepCopyObject() runtime.Object { } } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *NamespaceComposeConfig) DeepCopyInto(out *NamespaceComposeConfig) { - *out = *in - out.Namespaced = in.Namespaced - out.TypeMeta = in.TypeMeta - in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) - out.Spec = in.Spec - in.Status.DeepCopyInto(&out.Status) - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceComposeConfig. -func (in *NamespaceComposeConfig) DeepCopy() *NamespaceComposeConfig { - if in == nil { - return nil - } - out := new(NamespaceComposeConfig) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. -func (in *NamespaceComposeConfig) 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 *NamespaceComposeConfigList) DeepCopyInto(out *NamespaceComposeConfigList) { - *out = *in - out.TypeMeta = in.TypeMeta - out.ListMeta = in.ListMeta - if in.Items != nil { - in, out := &in.Items, &out.Items - *out = make([]NamespaceComposeConfig, len(*in)) - for i := range *in { - (*in)[i].DeepCopyInto(&(*out)[i]) - } - } - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceComposeConfigList. -func (in *NamespaceComposeConfigList) DeepCopy() *NamespaceComposeConfigList { - if in == nil { - return nil - } - out := new(NamespaceComposeConfigList) - in.DeepCopyInto(out) - return out -} - -// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. -func (in *NamespaceComposeConfigList) 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 *NamespaceComposeSpec) DeepCopyInto(out *NamespaceComposeSpec) { - *out = *in - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceComposeSpec. -func (in *NamespaceComposeSpec) DeepCopy() *NamespaceComposeSpec { - if in == nil { - return nil - } - out := new(NamespaceComposeSpec) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NamespacedBasicAuth) DeepCopyInto(out *NamespacedBasicAuth) { *out = *in diff --git a/apis/project.cattle.io/v3/zz_generated_k8s_client.go b/apis/project.cattle.io/v3/zz_generated_k8s_client.go index 0a7be137..4ecd6c01 100644 --- a/apis/project.cattle.io/v3/zz_generated_k8s_client.go +++ b/apis/project.cattle.io/v3/zz_generated_k8s_client.go @@ -28,7 +28,6 @@ type Interface interface { WorkloadsGetter AppsGetter AppRevisionsGetter - NamespaceComposeConfigsGetter } type Client struct { @@ -49,7 +48,6 @@ type Client struct { workloadControllers map[string]WorkloadController appControllers map[string]AppController appRevisionControllers map[string]AppRevisionController - namespaceComposeConfigControllers map[string]NamespaceComposeConfigController } func NewForConfig(config rest.Config) (Interface, error) { @@ -79,7 +77,6 @@ func NewForConfig(config rest.Config) (Interface, error) { workloadControllers: map[string]WorkloadController{}, appControllers: map[string]AppController{}, appRevisionControllers: map[string]AppRevisionController{}, - namespaceComposeConfigControllers: map[string]NamespaceComposeConfigController{}, }, nil } @@ -263,16 +260,3 @@ func (c *Client) AppRevisions(namespace string) AppRevisionInterface { objectClient: objectClient, } } - -type NamespaceComposeConfigsGetter interface { - NamespaceComposeConfigs(namespace string) NamespaceComposeConfigInterface -} - -func (c *Client) NamespaceComposeConfigs(namespace string) NamespaceComposeConfigInterface { - objectClient := objectclient.NewObjectClient(namespace, c.restClient, &NamespaceComposeConfigResource, NamespaceComposeConfigGroupVersionKind, namespaceComposeConfigFactory{}) - return &namespaceComposeConfigClient{ - ns: namespace, - client: c, - objectClient: objectClient, - } -} diff --git a/apis/project.cattle.io/v3/zz_generated_namespace_compose_config_controller.go b/apis/project.cattle.io/v3/zz_generated_namespace_compose_config_controller.go deleted file mode 100644 index 4fc4b7c2..00000000 --- a/apis/project.cattle.io/v3/zz_generated_namespace_compose_config_controller.go +++ /dev/null @@ -1,252 +0,0 @@ -package v3 - -import ( - "context" - - "github.com/rancher/norman/controller" - "github.com/rancher/norman/objectclient" - "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 ( - NamespaceComposeConfigGroupVersionKind = schema.GroupVersionKind{ - Version: Version, - Group: GroupName, - Kind: "NamespaceComposeConfig", - } - NamespaceComposeConfigResource = metav1.APIResource{ - Name: "namespacecomposeconfigs", - SingularName: "namespacecomposeconfig", - Namespaced: true, - - Kind: NamespaceComposeConfigGroupVersionKind.Kind, - } -) - -type NamespaceComposeConfigList struct { - metav1.TypeMeta `json:",inline"` - metav1.ListMeta `json:"metadata,omitempty"` - Items []NamespaceComposeConfig -} - -type NamespaceComposeConfigHandlerFunc func(key string, obj *NamespaceComposeConfig) error - -type NamespaceComposeConfigLister interface { - List(namespace string, selector labels.Selector) (ret []*NamespaceComposeConfig, err error) - Get(namespace, name string) (*NamespaceComposeConfig, error) -} - -type NamespaceComposeConfigController interface { - Informer() cache.SharedIndexInformer - Lister() NamespaceComposeConfigLister - AddHandler(name string, handler NamespaceComposeConfigHandlerFunc) - AddClusterScopedHandler(name, clusterName string, handler NamespaceComposeConfigHandlerFunc) - Enqueue(namespace, name string) - Sync(ctx context.Context) error - Start(ctx context.Context, threadiness int) error -} - -type NamespaceComposeConfigInterface interface { - ObjectClient() *objectclient.ObjectClient - Create(*NamespaceComposeConfig) (*NamespaceComposeConfig, error) - GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NamespaceComposeConfig, error) - Get(name string, opts metav1.GetOptions) (*NamespaceComposeConfig, error) - Update(*NamespaceComposeConfig) (*NamespaceComposeConfig, error) - Delete(name string, options *metav1.DeleteOptions) error - DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error - List(opts metav1.ListOptions) (*NamespaceComposeConfigList, error) - Watch(opts metav1.ListOptions) (watch.Interface, error) - DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error - Controller() NamespaceComposeConfigController - AddHandler(name string, sync NamespaceComposeConfigHandlerFunc) - AddLifecycle(name string, lifecycle NamespaceComposeConfigLifecycle) - AddClusterScopedHandler(name, clusterName string, sync NamespaceComposeConfigHandlerFunc) - AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespaceComposeConfigLifecycle) -} - -type namespaceComposeConfigLister struct { - controller *namespaceComposeConfigController -} - -func (l *namespaceComposeConfigLister) List(namespace string, selector labels.Selector) (ret []*NamespaceComposeConfig, err error) { - err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) { - ret = append(ret, obj.(*NamespaceComposeConfig)) - }) - return -} - -func (l *namespaceComposeConfigLister) Get(namespace, name string) (*NamespaceComposeConfig, 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: NamespaceComposeConfigGroupVersionKind.Group, - Resource: "namespaceComposeConfig", - }, name) - } - return obj.(*NamespaceComposeConfig), nil -} - -type namespaceComposeConfigController struct { - controller.GenericController -} - -func (c *namespaceComposeConfigController) Lister() NamespaceComposeConfigLister { - return &namespaceComposeConfigLister{ - controller: c, - } -} - -func (c *namespaceComposeConfigController) AddHandler(name string, handler NamespaceComposeConfigHandlerFunc) { - 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.(*NamespaceComposeConfig)) - }) -} - -func (c *namespaceComposeConfigController) AddClusterScopedHandler(name, cluster string, handler NamespaceComposeConfigHandlerFunc) { - 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.(*NamespaceComposeConfig)) - }) -} - -type namespaceComposeConfigFactory struct { -} - -func (c namespaceComposeConfigFactory) Object() runtime.Object { - return &NamespaceComposeConfig{} -} - -func (c namespaceComposeConfigFactory) List() runtime.Object { - return &NamespaceComposeConfigList{} -} - -func (s *namespaceComposeConfigClient) Controller() NamespaceComposeConfigController { - s.client.Lock() - defer s.client.Unlock() - - c, ok := s.client.namespaceComposeConfigControllers[s.ns] - if ok { - return c - } - - genericController := controller.NewGenericController(NamespaceComposeConfigGroupVersionKind.Kind+"Controller", - s.objectClient) - - c = &namespaceComposeConfigController{ - GenericController: genericController, - } - - s.client.namespaceComposeConfigControllers[s.ns] = c - s.client.starters = append(s.client.starters, c) - - return c -} - -type namespaceComposeConfigClient struct { - client *Client - ns string - objectClient *objectclient.ObjectClient - controller NamespaceComposeConfigController -} - -func (s *namespaceComposeConfigClient) ObjectClient() *objectclient.ObjectClient { - return s.objectClient -} - -func (s *namespaceComposeConfigClient) Create(o *NamespaceComposeConfig) (*NamespaceComposeConfig, error) { - obj, err := s.objectClient.Create(o) - return obj.(*NamespaceComposeConfig), err -} - -func (s *namespaceComposeConfigClient) Get(name string, opts metav1.GetOptions) (*NamespaceComposeConfig, error) { - obj, err := s.objectClient.Get(name, opts) - return obj.(*NamespaceComposeConfig), err -} - -func (s *namespaceComposeConfigClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NamespaceComposeConfig, error) { - obj, err := s.objectClient.GetNamespaced(namespace, name, opts) - return obj.(*NamespaceComposeConfig), err -} - -func (s *namespaceComposeConfigClient) Update(o *NamespaceComposeConfig) (*NamespaceComposeConfig, error) { - obj, err := s.objectClient.Update(o.Name, o) - return obj.(*NamespaceComposeConfig), err -} - -func (s *namespaceComposeConfigClient) Delete(name string, options *metav1.DeleteOptions) error { - return s.objectClient.Delete(name, options) -} - -func (s *namespaceComposeConfigClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error { - return s.objectClient.DeleteNamespaced(namespace, name, options) -} - -func (s *namespaceComposeConfigClient) List(opts metav1.ListOptions) (*NamespaceComposeConfigList, error) { - obj, err := s.objectClient.List(opts) - return obj.(*NamespaceComposeConfigList), err -} - -func (s *namespaceComposeConfigClient) Watch(opts metav1.ListOptions) (watch.Interface, error) { - return s.objectClient.Watch(opts) -} - -// Patch applies the patch and returns the patched deployment. -func (s *namespaceComposeConfigClient) Patch(o *NamespaceComposeConfig, data []byte, subresources ...string) (*NamespaceComposeConfig, error) { - obj, err := s.objectClient.Patch(o.Name, o, data, subresources...) - return obj.(*NamespaceComposeConfig), err -} - -func (s *namespaceComposeConfigClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error { - return s.objectClient.DeleteCollection(deleteOpts, listOpts) -} - -func (s *namespaceComposeConfigClient) AddHandler(name string, sync NamespaceComposeConfigHandlerFunc) { - s.Controller().AddHandler(name, sync) -} - -func (s *namespaceComposeConfigClient) AddLifecycle(name string, lifecycle NamespaceComposeConfigLifecycle) { - sync := NewNamespaceComposeConfigLifecycleAdapter(name, false, s, lifecycle) - s.AddHandler(name, sync) -} - -func (s *namespaceComposeConfigClient) AddClusterScopedHandler(name, clusterName string, sync NamespaceComposeConfigHandlerFunc) { - s.Controller().AddClusterScopedHandler(name, clusterName, sync) -} - -func (s *namespaceComposeConfigClient) AddClusterScopedLifecycle(name, clusterName string, lifecycle NamespaceComposeConfigLifecycle) { - sync := NewNamespaceComposeConfigLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle) - s.AddClusterScopedHandler(name, clusterName, sync) -} diff --git a/apis/project.cattle.io/v3/zz_generated_namespace_compose_config_lifecycle_adapter.go b/apis/project.cattle.io/v3/zz_generated_namespace_compose_config_lifecycle_adapter.go deleted file mode 100644 index 29af8bf2..00000000 --- a/apis/project.cattle.io/v3/zz_generated_namespace_compose_config_lifecycle_adapter.go +++ /dev/null @@ -1,51 +0,0 @@ -package v3 - -import ( - "github.com/rancher/norman/lifecycle" - "k8s.io/apimachinery/pkg/runtime" -) - -type NamespaceComposeConfigLifecycle interface { - Create(obj *NamespaceComposeConfig) (*NamespaceComposeConfig, error) - Remove(obj *NamespaceComposeConfig) (*NamespaceComposeConfig, error) - Updated(obj *NamespaceComposeConfig) (*NamespaceComposeConfig, error) -} - -type namespaceComposeConfigLifecycleAdapter struct { - lifecycle NamespaceComposeConfigLifecycle -} - -func (w *namespaceComposeConfigLifecycleAdapter) Create(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Create(obj.(*NamespaceComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func (w *namespaceComposeConfigLifecycleAdapter) Finalize(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Remove(obj.(*NamespaceComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func (w *namespaceComposeConfigLifecycleAdapter) Updated(obj runtime.Object) (runtime.Object, error) { - o, err := w.lifecycle.Updated(obj.(*NamespaceComposeConfig)) - if o == nil { - return nil, err - } - return o, err -} - -func NewNamespaceComposeConfigLifecycleAdapter(name string, clusterScoped bool, client NamespaceComposeConfigInterface, l NamespaceComposeConfigLifecycle) NamespaceComposeConfigHandlerFunc { - adapter := &namespaceComposeConfigLifecycleAdapter{lifecycle: l} - syncFn := lifecycle.NewObjectLifecycleAdapter(name, clusterScoped, adapter, client.ObjectClient()) - return func(key string, obj *NamespaceComposeConfig) error { - if obj == nil { - return syncFn(key, nil) - } - return syncFn(key, obj) - } -} diff --git a/apis/project.cattle.io/v3/zz_generated_scheme.go b/apis/project.cattle.io/v3/zz_generated_scheme.go index 00fd6e0f..0b5e547d 100644 --- a/apis/project.cattle.io/v3/zz_generated_scheme.go +++ b/apis/project.cattle.io/v3/zz_generated_scheme.go @@ -59,8 +59,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &AppList{}, &AppRevision{}, &AppRevisionList{}, - &NamespaceComposeConfig{}, - &NamespaceComposeConfigList{}, ) return nil } diff --git a/client/management/v3/zz_generated_client.go b/client/management/v3/zz_generated_client.go index 7a334335..500f37a2 100644 --- a/client/management/v3/zz_generated_client.go +++ b/client/management/v3/zz_generated_client.go @@ -48,8 +48,7 @@ type Client struct { PipelineExecution PipelineExecutionOperations PipelineExecutionLog PipelineExecutionLogOperations SourceCodeRepository SourceCodeRepositoryOperations - GlobalComposeConfig GlobalComposeConfigOperations - ClusterComposeConfig ClusterComposeConfigOperations + ComposeConfig ComposeConfigOperations } func NewClient(opts *clientbase.ClientOpts) (*Client, error) { @@ -103,8 +102,7 @@ func NewClient(opts *clientbase.ClientOpts) (*Client, error) { client.PipelineExecution = newPipelineExecutionClient(client) client.PipelineExecutionLog = newPipelineExecutionLogClient(client) client.SourceCodeRepository = newSourceCodeRepositoryClient(client) - client.GlobalComposeConfig = newGlobalComposeConfigClient(client) - client.ClusterComposeConfig = newClusterComposeConfigClient(client) + client.ComposeConfig = newComposeConfigClient(client) return client, nil } diff --git a/client/management/v3/zz_generated_cluster_compose_config.go b/client/management/v3/zz_generated_cluster_compose_config.go deleted file mode 100644 index d054da22..00000000 --- a/client/management/v3/zz_generated_cluster_compose_config.go +++ /dev/null @@ -1,105 +0,0 @@ -package client - -import ( - "github.com/rancher/norman/types" -) - -const ( - ClusterComposeConfigType = "clusterComposeConfig" - ClusterComposeConfigFieldAnnotations = "annotations" - ClusterComposeConfigFieldClusterId = "clusterId" - ClusterComposeConfigFieldCreated = "created" - ClusterComposeConfigFieldCreatorID = "creatorId" - ClusterComposeConfigFieldLabels = "labels" - ClusterComposeConfigFieldName = "name" - ClusterComposeConfigFieldNamespaceId = "namespaceId" - ClusterComposeConfigFieldOwnerReferences = "ownerReferences" - ClusterComposeConfigFieldRancherCompose = "rancherCompose" - ClusterComposeConfigFieldRemoved = "removed" - ClusterComposeConfigFieldState = "state" - ClusterComposeConfigFieldStatus = "status" - ClusterComposeConfigFieldTransitioning = "transitioning" - ClusterComposeConfigFieldTransitioningMessage = "transitioningMessage" - ClusterComposeConfigFieldUuid = "uuid" -) - -type ClusterComposeConfig struct { - types.Resource - Annotations map[string]string `json:"annotations,omitempty" yaml:"annotations,omitempty"` - ClusterId string `json:"clusterId,omitempty" yaml:"clusterId,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"` - NamespaceId string `json:"namespaceId,omitempty" yaml:"namespaceId,omitempty"` - OwnerReferences []OwnerReference `json:"ownerReferences,omitempty" yaml:"ownerReferences,omitempty"` - RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancherCompose,omitempty"` - Removed string `json:"removed,omitempty" yaml:"removed,omitempty"` - State string `json:"state,omitempty" yaml:"state,omitempty"` - Status *ComposeStatus `json:"status,omitempty" yaml:"status,omitempty"` - Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"` - TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioningMessage,omitempty"` - Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"` -} -type ClusterComposeConfigCollection struct { - types.Collection - Data []ClusterComposeConfig `json:"data,omitempty"` - client *ClusterComposeConfigClient -} - -type ClusterComposeConfigClient struct { - apiClient *Client -} - -type ClusterComposeConfigOperations interface { - List(opts *types.ListOpts) (*ClusterComposeConfigCollection, error) - Create(opts *ClusterComposeConfig) (*ClusterComposeConfig, error) - Update(existing *ClusterComposeConfig, updates interface{}) (*ClusterComposeConfig, error) - ByID(id string) (*ClusterComposeConfig, error) - Delete(container *ClusterComposeConfig) error -} - -func newClusterComposeConfigClient(apiClient *Client) *ClusterComposeConfigClient { - return &ClusterComposeConfigClient{ - apiClient: apiClient, - } -} - -func (c *ClusterComposeConfigClient) Create(container *ClusterComposeConfig) (*ClusterComposeConfig, error) { - resp := &ClusterComposeConfig{} - err := c.apiClient.Ops.DoCreate(ClusterComposeConfigType, container, resp) - return resp, err -} - -func (c *ClusterComposeConfigClient) Update(existing *ClusterComposeConfig, updates interface{}) (*ClusterComposeConfig, error) { - resp := &ClusterComposeConfig{} - err := c.apiClient.Ops.DoUpdate(ClusterComposeConfigType, &existing.Resource, updates, resp) - return resp, err -} - -func (c *ClusterComposeConfigClient) List(opts *types.ListOpts) (*ClusterComposeConfigCollection, error) { - resp := &ClusterComposeConfigCollection{} - err := c.apiClient.Ops.DoList(ClusterComposeConfigType, opts, resp) - resp.client = c - return resp, err -} - -func (cc *ClusterComposeConfigCollection) Next() (*ClusterComposeConfigCollection, error) { - if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" { - resp := &ClusterComposeConfigCollection{} - err := cc.client.apiClient.Ops.DoNext(cc.Pagination.Next, resp) - resp.client = cc.client - return resp, err - } - return nil, nil -} - -func (c *ClusterComposeConfigClient) ByID(id string) (*ClusterComposeConfig, error) { - resp := &ClusterComposeConfig{} - err := c.apiClient.Ops.DoByID(ClusterComposeConfigType, id, resp) - return resp, err -} - -func (c *ClusterComposeConfigClient) Delete(container *ClusterComposeConfig) error { - return c.apiClient.Ops.DoResourceDelete(ClusterComposeConfigType, &container.Resource) -} diff --git a/client/management/v3/zz_generated_cluster_compose_spec.go b/client/management/v3/zz_generated_cluster_compose_spec.go deleted file mode 100644 index 935889a2..00000000 --- a/client/management/v3/zz_generated_cluster_compose_spec.go +++ /dev/null @@ -1,12 +0,0 @@ -package client - -const ( - ClusterComposeSpecType = "clusterComposeSpec" - ClusterComposeSpecFieldClusterId = "clusterId" - ClusterComposeSpecFieldRancherCompose = "rancherCompose" -) - -type ClusterComposeSpec struct { - ClusterId string `json:"clusterId,omitempty" yaml:"clusterId,omitempty"` - RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancherCompose,omitempty"` -} diff --git a/client/management/v3/zz_generated_compose_config.go b/client/management/v3/zz_generated_compose_config.go new file mode 100644 index 00000000..f996a144 --- /dev/null +++ b/client/management/v3/zz_generated_compose_config.go @@ -0,0 +1,101 @@ +package client + +import ( + "github.com/rancher/norman/types" +) + +const ( + ComposeConfigType = "composeConfig" + ComposeConfigFieldAnnotations = "annotations" + ComposeConfigFieldCreated = "created" + ComposeConfigFieldCreatorID = "creatorId" + ComposeConfigFieldLabels = "labels" + ComposeConfigFieldName = "name" + ComposeConfigFieldOwnerReferences = "ownerReferences" + ComposeConfigFieldRancherCompose = "rancherCompose" + ComposeConfigFieldRemoved = "removed" + ComposeConfigFieldState = "state" + ComposeConfigFieldStatus = "status" + ComposeConfigFieldTransitioning = "transitioning" + ComposeConfigFieldTransitioningMessage = "transitioningMessage" + ComposeConfigFieldUuid = "uuid" +) + +type ComposeConfig 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"` + RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancherCompose,omitempty"` + Removed string `json:"removed,omitempty" yaml:"removed,omitempty"` + State string `json:"state,omitempty" yaml:"state,omitempty"` + Status *ComposeStatus `json:"status,omitempty" yaml:"status,omitempty"` + Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"` + TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioningMessage,omitempty"` + Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"` +} +type ComposeConfigCollection struct { + types.Collection + Data []ComposeConfig `json:"data,omitempty"` + client *ComposeConfigClient +} + +type ComposeConfigClient struct { + apiClient *Client +} + +type ComposeConfigOperations interface { + List(opts *types.ListOpts) (*ComposeConfigCollection, error) + Create(opts *ComposeConfig) (*ComposeConfig, error) + Update(existing *ComposeConfig, updates interface{}) (*ComposeConfig, error) + ByID(id string) (*ComposeConfig, error) + Delete(container *ComposeConfig) error +} + +func newComposeConfigClient(apiClient *Client) *ComposeConfigClient { + return &ComposeConfigClient{ + apiClient: apiClient, + } +} + +func (c *ComposeConfigClient) Create(container *ComposeConfig) (*ComposeConfig, error) { + resp := &ComposeConfig{} + err := c.apiClient.Ops.DoCreate(ComposeConfigType, container, resp) + return resp, err +} + +func (c *ComposeConfigClient) Update(existing *ComposeConfig, updates interface{}) (*ComposeConfig, error) { + resp := &ComposeConfig{} + err := c.apiClient.Ops.DoUpdate(ComposeConfigType, &existing.Resource, updates, resp) + return resp, err +} + +func (c *ComposeConfigClient) List(opts *types.ListOpts) (*ComposeConfigCollection, error) { + resp := &ComposeConfigCollection{} + err := c.apiClient.Ops.DoList(ComposeConfigType, opts, resp) + resp.client = c + return resp, err +} + +func (cc *ComposeConfigCollection) Next() (*ComposeConfigCollection, error) { + if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" { + resp := &ComposeConfigCollection{} + err := cc.client.apiClient.Ops.DoNext(cc.Pagination.Next, resp) + resp.client = cc.client + return resp, err + } + return nil, nil +} + +func (c *ComposeConfigClient) ByID(id string) (*ComposeConfig, error) { + resp := &ComposeConfig{} + err := c.apiClient.Ops.DoByID(ComposeConfigType, id, resp) + return resp, err +} + +func (c *ComposeConfigClient) Delete(container *ComposeConfig) error { + return c.apiClient.Ops.DoResourceDelete(ComposeConfigType, &container.Resource) +} diff --git a/client/management/v3/zz_generated_global_compose_config.go b/client/management/v3/zz_generated_global_compose_config.go deleted file mode 100644 index 6fbc69ef..00000000 --- a/client/management/v3/zz_generated_global_compose_config.go +++ /dev/null @@ -1,101 +0,0 @@ -package client - -import ( - "github.com/rancher/norman/types" -) - -const ( - GlobalComposeConfigType = "globalComposeConfig" - GlobalComposeConfigFieldAnnotations = "annotations" - GlobalComposeConfigFieldCreated = "created" - GlobalComposeConfigFieldCreatorID = "creatorId" - GlobalComposeConfigFieldLabels = "labels" - GlobalComposeConfigFieldName = "name" - GlobalComposeConfigFieldOwnerReferences = "ownerReferences" - GlobalComposeConfigFieldRancherCompose = "rancherCompose" - GlobalComposeConfigFieldRemoved = "removed" - GlobalComposeConfigFieldState = "state" - GlobalComposeConfigFieldStatus = "status" - GlobalComposeConfigFieldTransitioning = "transitioning" - GlobalComposeConfigFieldTransitioningMessage = "transitioningMessage" - GlobalComposeConfigFieldUuid = "uuid" -) - -type GlobalComposeConfig 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"` - RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancherCompose,omitempty"` - Removed string `json:"removed,omitempty" yaml:"removed,omitempty"` - State string `json:"state,omitempty" yaml:"state,omitempty"` - Status *ComposeStatus `json:"status,omitempty" yaml:"status,omitempty"` - Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"` - TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioningMessage,omitempty"` - Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"` -} -type GlobalComposeConfigCollection struct { - types.Collection - Data []GlobalComposeConfig `json:"data,omitempty"` - client *GlobalComposeConfigClient -} - -type GlobalComposeConfigClient struct { - apiClient *Client -} - -type GlobalComposeConfigOperations interface { - List(opts *types.ListOpts) (*GlobalComposeConfigCollection, error) - Create(opts *GlobalComposeConfig) (*GlobalComposeConfig, error) - Update(existing *GlobalComposeConfig, updates interface{}) (*GlobalComposeConfig, error) - ByID(id string) (*GlobalComposeConfig, error) - Delete(container *GlobalComposeConfig) error -} - -func newGlobalComposeConfigClient(apiClient *Client) *GlobalComposeConfigClient { - return &GlobalComposeConfigClient{ - apiClient: apiClient, - } -} - -func (c *GlobalComposeConfigClient) Create(container *GlobalComposeConfig) (*GlobalComposeConfig, error) { - resp := &GlobalComposeConfig{} - err := c.apiClient.Ops.DoCreate(GlobalComposeConfigType, container, resp) - return resp, err -} - -func (c *GlobalComposeConfigClient) Update(existing *GlobalComposeConfig, updates interface{}) (*GlobalComposeConfig, error) { - resp := &GlobalComposeConfig{} - err := c.apiClient.Ops.DoUpdate(GlobalComposeConfigType, &existing.Resource, updates, resp) - return resp, err -} - -func (c *GlobalComposeConfigClient) List(opts *types.ListOpts) (*GlobalComposeConfigCollection, error) { - resp := &GlobalComposeConfigCollection{} - err := c.apiClient.Ops.DoList(GlobalComposeConfigType, opts, resp) - resp.client = c - return resp, err -} - -func (cc *GlobalComposeConfigCollection) Next() (*GlobalComposeConfigCollection, error) { - if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" { - resp := &GlobalComposeConfigCollection{} - err := cc.client.apiClient.Ops.DoNext(cc.Pagination.Next, resp) - resp.client = cc.client - return resp, err - } - return nil, nil -} - -func (c *GlobalComposeConfigClient) ByID(id string) (*GlobalComposeConfig, error) { - resp := &GlobalComposeConfig{} - err := c.apiClient.Ops.DoByID(GlobalComposeConfigType, id, resp) - return resp, err -} - -func (c *GlobalComposeConfigClient) Delete(container *GlobalComposeConfig) error { - return c.apiClient.Ops.DoResourceDelete(GlobalComposeConfigType, &container.Resource) -} diff --git a/client/management/v3/zz_generated_project.go b/client/management/v3/zz_generated_project.go index 0ada63c9..c28167a1 100644 --- a/client/management/v3/zz_generated_project.go +++ b/client/management/v3/zz_generated_project.go @@ -60,6 +60,8 @@ type ProjectOperations interface { ByID(id string) (*Project, error) Delete(container *Project) error + ActionExportYaml(resource *Project) error + ActionSetpodsecuritypolicytemplate(resource *Project, input *SetPodSecurityPolicyTemplateInput) (*Project, error) } @@ -108,6 +110,11 @@ func (c *ProjectClient) Delete(container *Project) error { return c.apiClient.Ops.DoResourceDelete(ProjectType, &container.Resource) } +func (c *ProjectClient) ActionExportYaml(resource *Project) error { + err := c.apiClient.Ops.DoAction(ProjectType, "exportYaml", &resource.Resource, nil, nil) + return err +} + func (c *ProjectClient) ActionSetpodsecuritypolicytemplate(resource *Project, input *SetPodSecurityPolicyTemplateInput) (*Project, error) { resp := &Project{} err := c.apiClient.Ops.DoAction(ProjectType, "setpodsecuritypolicytemplate", &resource.Resource, input, resp) diff --git a/client/project/v3/zz_generated_client.go b/client/project/v3/zz_generated_client.go index bc20dd36..e2a01451 100644 --- a/client/project/v3/zz_generated_client.go +++ b/client/project/v3/zz_generated_client.go @@ -35,7 +35,6 @@ type Client struct { Workload WorkloadOperations App AppOperations AppRevision AppRevisionOperations - NamespaceComposeConfig NamespaceComposeConfigOperations } func NewClient(opts *clientbase.ClientOpts) (*Client, error) { @@ -76,7 +75,6 @@ func NewClient(opts *clientbase.ClientOpts) (*Client, error) { client.Workload = newWorkloadClient(client) client.App = newAppClient(client) client.AppRevision = newAppRevisionClient(client) - client.NamespaceComposeConfig = newNamespaceComposeConfigClient(client) return client, nil } diff --git a/client/project/v3/zz_generated_compose_condition.go b/client/project/v3/zz_generated_compose_condition.go deleted file mode 100644 index e2b5a1ec..00000000 --- a/client/project/v3/zz_generated_compose_condition.go +++ /dev/null @@ -1,20 +0,0 @@ -package client - -const ( - ComposeConditionType = "composeCondition" - ComposeConditionFieldLastTransitionTime = "lastTransitionTime" - ComposeConditionFieldLastUpdateTime = "lastUpdateTime" - ComposeConditionFieldMessage = "message" - ComposeConditionFieldReason = "reason" - ComposeConditionFieldStatus = "status" - ComposeConditionFieldType = "type" -) - -type ComposeCondition struct { - LastTransitionTime string `json:"lastTransitionTime,omitempty" yaml:"lastTransitionTime,omitempty"` - LastUpdateTime string `json:"lastUpdateTime,omitempty" yaml:"lastUpdateTime,omitempty"` - Message string `json:"message,omitempty" yaml:"message,omitempty"` - Reason string `json:"reason,omitempty" yaml:"reason,omitempty"` - Status string `json:"status,omitempty" yaml:"status,omitempty"` - Type string `json:"type,omitempty" yaml:"type,omitempty"` -} diff --git a/client/project/v3/zz_generated_compose_status.go b/client/project/v3/zz_generated_compose_status.go deleted file mode 100644 index 53138f03..00000000 --- a/client/project/v3/zz_generated_compose_status.go +++ /dev/null @@ -1,10 +0,0 @@ -package client - -const ( - ComposeStatusType = "composeStatus" - ComposeStatusFieldConditions = "conditions" -) - -type ComposeStatus struct { - Conditions []ComposeCondition `json:"conditions,omitempty" yaml:"conditions,omitempty"` -} diff --git a/client/project/v3/zz_generated_namespace_compose_config.go b/client/project/v3/zz_generated_namespace_compose_config.go deleted file mode 100644 index 86b694a1..00000000 --- a/client/project/v3/zz_generated_namespace_compose_config.go +++ /dev/null @@ -1,107 +0,0 @@ -package client - -import ( - "github.com/rancher/norman/types" -) - -const ( - NamespaceComposeConfigType = "namespaceComposeConfig" - NamespaceComposeConfigFieldAnnotations = "annotations" - NamespaceComposeConfigFieldCreated = "created" - NamespaceComposeConfigFieldCreatorID = "creatorId" - NamespaceComposeConfigFieldInstallNamespace = "installNamespace" - NamespaceComposeConfigFieldLabels = "labels" - NamespaceComposeConfigFieldName = "name" - NamespaceComposeConfigFieldNamespaceId = "namespaceId" - NamespaceComposeConfigFieldOwnerReferences = "ownerReferences" - NamespaceComposeConfigFieldProjectId = "projectId" - NamespaceComposeConfigFieldRancherCompose = "rancherCompose" - NamespaceComposeConfigFieldRemoved = "removed" - NamespaceComposeConfigFieldState = "state" - NamespaceComposeConfigFieldStatus = "status" - NamespaceComposeConfigFieldTransitioning = "transitioning" - NamespaceComposeConfigFieldTransitioningMessage = "transitioningMessage" - NamespaceComposeConfigFieldUuid = "uuid" -) - -type NamespaceComposeConfig 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"` - InstallNamespace string `json:"installNamespace,omitempty" yaml:"installNamespace,omitempty"` - Labels map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"` - Name string `json:"name,omitempty" yaml:"name,omitempty"` - NamespaceId string `json:"namespaceId,omitempty" yaml:"namespaceId,omitempty"` - OwnerReferences []OwnerReference `json:"ownerReferences,omitempty" yaml:"ownerReferences,omitempty"` - ProjectId string `json:"projectId,omitempty" yaml:"projectId,omitempty"` - RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancherCompose,omitempty"` - Removed string `json:"removed,omitempty" yaml:"removed,omitempty"` - State string `json:"state,omitempty" yaml:"state,omitempty"` - Status *ComposeStatus `json:"status,omitempty" yaml:"status,omitempty"` - Transitioning string `json:"transitioning,omitempty" yaml:"transitioning,omitempty"` - TransitioningMessage string `json:"transitioningMessage,omitempty" yaml:"transitioningMessage,omitempty"` - Uuid string `json:"uuid,omitempty" yaml:"uuid,omitempty"` -} -type NamespaceComposeConfigCollection struct { - types.Collection - Data []NamespaceComposeConfig `json:"data,omitempty"` - client *NamespaceComposeConfigClient -} - -type NamespaceComposeConfigClient struct { - apiClient *Client -} - -type NamespaceComposeConfigOperations interface { - List(opts *types.ListOpts) (*NamespaceComposeConfigCollection, error) - Create(opts *NamespaceComposeConfig) (*NamespaceComposeConfig, error) - Update(existing *NamespaceComposeConfig, updates interface{}) (*NamespaceComposeConfig, error) - ByID(id string) (*NamespaceComposeConfig, error) - Delete(container *NamespaceComposeConfig) error -} - -func newNamespaceComposeConfigClient(apiClient *Client) *NamespaceComposeConfigClient { - return &NamespaceComposeConfigClient{ - apiClient: apiClient, - } -} - -func (c *NamespaceComposeConfigClient) Create(container *NamespaceComposeConfig) (*NamespaceComposeConfig, error) { - resp := &NamespaceComposeConfig{} - err := c.apiClient.Ops.DoCreate(NamespaceComposeConfigType, container, resp) - return resp, err -} - -func (c *NamespaceComposeConfigClient) Update(existing *NamespaceComposeConfig, updates interface{}) (*NamespaceComposeConfig, error) { - resp := &NamespaceComposeConfig{} - err := c.apiClient.Ops.DoUpdate(NamespaceComposeConfigType, &existing.Resource, updates, resp) - return resp, err -} - -func (c *NamespaceComposeConfigClient) List(opts *types.ListOpts) (*NamespaceComposeConfigCollection, error) { - resp := &NamespaceComposeConfigCollection{} - err := c.apiClient.Ops.DoList(NamespaceComposeConfigType, opts, resp) - resp.client = c - return resp, err -} - -func (cc *NamespaceComposeConfigCollection) Next() (*NamespaceComposeConfigCollection, error) { - if cc != nil && cc.Pagination != nil && cc.Pagination.Next != "" { - resp := &NamespaceComposeConfigCollection{} - err := cc.client.apiClient.Ops.DoNext(cc.Pagination.Next, resp) - resp.client = cc.client - return resp, err - } - return nil, nil -} - -func (c *NamespaceComposeConfigClient) ByID(id string) (*NamespaceComposeConfig, error) { - resp := &NamespaceComposeConfig{} - err := c.apiClient.Ops.DoByID(NamespaceComposeConfigType, id, resp) - return resp, err -} - -func (c *NamespaceComposeConfigClient) Delete(container *NamespaceComposeConfig) error { - return c.apiClient.Ops.DoResourceDelete(NamespaceComposeConfigType, &container.Resource) -} diff --git a/client/project/v3/zz_generated_namespace_compose_spec.go b/client/project/v3/zz_generated_namespace_compose_spec.go deleted file mode 100644 index aa7e2dcc..00000000 --- a/client/project/v3/zz_generated_namespace_compose_spec.go +++ /dev/null @@ -1,14 +0,0 @@ -package client - -const ( - NamespaceComposeSpecType = "namespaceComposeSpec" - NamespaceComposeSpecFieldInstallNamespace = "installNamespace" - NamespaceComposeSpecFieldProjectId = "projectId" - NamespaceComposeSpecFieldRancherCompose = "rancherCompose" -) - -type NamespaceComposeSpec struct { - InstallNamespace string `json:"installNamespace,omitempty" yaml:"installNamespace,omitempty"` - ProjectId string `json:"projectId,omitempty" yaml:"projectId,omitempty"` - RancherCompose string `json:"rancherCompose,omitempty" yaml:"rancherCompose,omitempty"` -} diff --git a/compose/zz_generated_compose.go b/compose/zz_generated_compose.go index 071c27ba..aa09bdbd 100644 --- a/compose/zz_generated_compose.go +++ b/compose/zz_generated_compose.go @@ -48,8 +48,7 @@ type Config struct { PipelineExecutions map[string]managementClient.PipelineExecution `json:"pipelineExecutions,omitempty" yaml:"pipelineExecutions,omitempty"` PipelineExecutionLogs map[string]managementClient.PipelineExecutionLog `json:"pipelineExecutionLogs,omitempty" yaml:"pipelineExecutionLogs,omitempty"` SourceCodeRepositorys map[string]managementClient.SourceCodeRepository `json:"sourceCodeRepositories,omitempty" yaml:"sourceCodeRepositories,omitempty"` - GlobalComposeConfigs map[string]managementClient.GlobalComposeConfig `json:"globalComposeConfigs,omitempty" yaml:"globalComposeConfigs,omitempty"` - ClusterComposeConfigs map[string]managementClient.ClusterComposeConfig `json:"clusterComposeConfigs,omitempty" yaml:"clusterComposeConfigs,omitempty"` + ComposeConfigs map[string]managementClient.ComposeConfig `json:"composeConfigs,omitempty" yaml:"composeConfigs,omitempty"` // Cluster Client Namespaces map[string]clusterClient.Namespace `json:"namespaces,omitempty" yaml:"namespaces,omitempty"` @@ -85,5 +84,4 @@ type Config struct { Workloads map[string]projectClient.Workload `json:"workloads,omitempty" yaml:"workloads,omitempty"` Apps map[string]projectClient.App `json:"apps,omitempty" yaml:"apps,omitempty"` AppRevisions map[string]projectClient.AppRevision `json:"appRevisions,omitempty" yaml:"appRevisions,omitempty"` - NamespaceComposeConfigs map[string]projectClient.NamespaceComposeConfig `json:"namespaceComposeConfigs,omitempty" yaml:"namespaceComposeConfigs,omitempty"` }