From d3fcbf4d45a34a07c51661147c56b6ae94bd2680 Mon Sep 17 00:00:00 2001 From: yangsoon Date: Mon, 17 May 2021 22:47:57 +0800 Subject: [PATCH] fix bug: remove unneeded workload definitions (#1656) * fix controller * fix test --- e2e/commonContext.go | 2 +- .../componentdefinition_controller.go | 31 +- .../componentdefinition_controller_test.go | 346 ++++++------------ .../components/componentdefinition/handler.go | 84 ----- pkg/controller/utils/capability.go | 38 +- test/e2e-test/app_embed_rollout_test.go | 5 + test/e2e-test/app_resourcetracker_test.go | 5 + test/e2e-test/app_revision_clean_up_test.go | 5 + test/e2e-test/definition_revision_test.go | 10 +- test/e2e-test/definition_test.go | 74 +++- 10 files changed, 218 insertions(+), 382 deletions(-) delete mode 100644 pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/handler.go diff --git a/e2e/commonContext.go b/e2e/commonContext.go index 0ddbb9a85..93028320b 100644 --- a/e2e/commonContext.go +++ b/e2e/commonContext.go @@ -141,7 +141,7 @@ var ( WorkloadCapabilityListContext = func() bool { return ginkgo.Context("list workload capabilities", func() { ginkgo.It("should sync capabilities from cluster before listing workload capabilities", func() { - output, err := Exec("vela workloads") + output, err := Exec("vela components") gomega.Expect(err).NotTo(gomega.HaveOccurred()) gomega.Expect(output).To(gomega.ContainSubstring("webservice")) }) diff --git a/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller.go b/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller.go index 35fcbe310..60ab9f5f5 100644 --- a/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller.go +++ b/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller.go @@ -74,12 +74,6 @@ func (r *Reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) { return ctrl.Result{}, nil } - handler := handler{ - Client: r.Client, - dm: r.dm, - cd: &componentDefinition, - } - // refresh package discover when componentDefinition is registered err := utils.RefreshPackageDiscover(ctx, r.Client, r.dm, r.pd, &componentDefinition) if err != nil { @@ -93,7 +87,7 @@ func (r *Reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) { defRev, isNewRevision, err := coredef.GenerateDefinitionRevision(ctx, r.Client, &componentDefinition) if err != nil { klog.ErrorS(err, "cannot generate DefinitionRevision", "ComponentDefinitionName", componentDefinition.Name) - r.record.Event(handler.cd, event.Warning("cannot generate DefinitionRevision", err)) + r.record.Event(&componentDefinition, event.Warning("cannot generate DefinitionRevision", err)) return ctrl.Result{}, util.PatchCondition(ctx, r, &componentDefinition, cpv1alpha1.ReconcileError(fmt.Errorf(util.ErrGenerateDefinitionRevision, componentDefinition.Name, err))) } @@ -114,28 +108,7 @@ func (r *Reconciler) Reconcile(req ctrl.Request) (ctrl.Result, error) { return ctrl.Result{}, nil } - workloadType, err := handler.CreateWorkloadDefinition(ctx) - if err != nil { - klog.ErrorS(err, "cannot create converted WorkloadDefinition") - r.record.Event(&componentDefinition, event.Warning("cannot store capability in ConfigMap", err)) - return ctrl.Result{}, util.PatchCondition(ctx, r, &componentDefinition, - cpv1alpha1.ReconcileError(fmt.Errorf(util.ErrCreateConvertedWorklaodDefinition, componentDefinition.Name, err))) - } - klog.InfoS("Successfully create WorkloadDefinition", "name", componentDefinition.Name) - - var def utils.CapabilityComponentDefinition - def.Name = req.NamespacedName.Name - def.WorkloadType = workloadType - def.ComponentDefinition = componentDefinition - switch workloadType { - case util.ReferWorkload: - def.WorkloadDefName = componentDefinition.Spec.Workload.Type - case util.HELMDef: - def.Helm = componentDefinition.Spec.Schematic.HELM - case util.KubeDef: - def.Kube = componentDefinition.Spec.Schematic.KUBE - default: - } + def := utils.NewCapabilityComponentDef(&componentDefinition) // Store the parameter of componentDefinition to configMap err = def.StoreOpenAPISchema(ctx, r.Client, r.pd, req.Namespace, req.Name, defRev.Name) diff --git a/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller_test.go b/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller_test.go index 20ff78ff4..3240ec069 100644 --- a/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller_test.go +++ b/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/componentdefinition_controller_test.go @@ -27,6 +27,7 @@ import ( corev1 "k8s.io/api/core/v1" crdv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" "k8s.io/utils/pointer" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -275,7 +276,98 @@ spec: }) }) - Context("When the ComponentDefinition is invalid, should hit issues", func() { + Context("When the ComponentDefinition contains Helm Module, should create a ConfigMap", func() { + var componentDefinitionName = "cd-with-helm-module" + var namespace = "default" + req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}} + + It("Applying ComponentDefinition with Helm module", func() { + cd := v1beta1.ComponentDefinition{} + cd.SetName(componentDefinitionName) + cd.SetNamespace(namespace) + cd.Spec.Workload.Definition = common.WorkloadGVK{APIVersion: "apps/v1", Kind: "Deployment"} + cd.Spec.Schematic = &common.Schematic{ + HELM: &common.Helm{ + Release: util.Object2RawExtension(map[string]interface{}{ + "chart": map[string]interface{}{ + "spec": map[string]interface{}{ + "chart": "podinfo", + "version": "5.1.4", + }, + }, + }), + Repository: util.Object2RawExtension(map[string]interface{}{ + "url": "http://oam.dev/catalog/", + }), + }, + } + By("Create ComponentDefinition") + Expect(k8sClient.Create(ctx, &cd)).Should(Succeed()) + reconcileRetry(&r, req) + + By("Check whether ConfigMap is created") + var cm corev1.ConfigMap + name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinitionName) + Eventually(func() bool { + err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm) + return err == nil + }, 10*time.Second, time.Second).Should(BeTrue()) + Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal(""))) + + By("Check whether ConfigMapRef refer to right ConfigMap") + Eventually(func() string { + _ = k8sClient.Get(ctx, client.ObjectKey{Namespace: cd.Namespace, Name: cd.Name}, &cd) + return cd.Status.ConfigMapRef + }, 10*time.Second, time.Second).Should(Equal(name)) + }) + }) + + Context("When the ComponentDefinition contains Kube Module, should create a ConfigMap", func() { + var componentDefinitionName = "cd-with-kube-module" + var namespace = "default" + req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}} + + It("Applying ComponentDefinition with kube Module", func() { + cd := v1beta1.ComponentDefinition{} + cd.SetName(componentDefinitionName) + cd.SetNamespace(namespace) + cd.Spec.Workload.Definition = common.WorkloadGVK{APIVersion: "apps/v1", Kind: "Deployment"} + cd.Spec.Schematic = &common.Schematic{ + KUBE: &common.Kube{ + Template: generateTemplate(KUBEWorkerTemplate), + Parameters: []common.KubeParameter{ + { + Name: "image", + ValueType: common.StringType, + FieldPaths: []string{"spec.template.spec.containers[0].image"}, + Required: pointer.BoolPtr(true), + Description: pointer.StringPtr("test description"), + }, + }, + }, + } + By("Create ComponentDefinition") + Expect(k8sClient.Create(ctx, &cd)).Should(Succeed()) + reconcileRetry(&r, req) + + By("Check whether ConfigMap is created") + var cm corev1.ConfigMap + name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinitionName) + Eventually(func() bool { + err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm) + return err == nil + }, 10*time.Second, time.Second).Should(BeTrue()) + Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal(""))) + + By("Check whether ConfigMapRef refer to right ConfigMap") + Eventually(func() string { + _ = k8sClient.Get(ctx, client.ObjectKey{Namespace: cd.Namespace, Name: cd.Name}, &cd) + return cd.Status.ConfigMapRef + }, 10*time.Second, time.Second).Should(Equal(name)) + }) + }) + + Context("When the ComponentDefinition is invalid, should raise errors", func() { var namespace = "ns-def" BeforeEach(func() { ns = corev1.Namespace{ @@ -404,224 +496,6 @@ spec: }) }) - Context("When the ComponentDefinition only contains Workload.Definition, should create a WorkloadDefinition", func() { - var componentDefinitionName = "cd-with-workload-definition" - var namespace = "default" - req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}} - - It("Applying ComponentDefinition with Workload.Definition", func() { - By("Apply ComponentDefinition") - var validComponentDefinition = ` -apiVersion: core.oam.dev/v1beta1 -kind: ComponentDefinition -metadata: - name: cd-with-workload-definition - annotations: - definition.oam.dev/description: "test" -spec: - workload: - definition: - apiVersion: apps/v1 - kind: Deployment - schematic: - cue: - template: | - output: { - apiVersion: "apps/v1" - kind: "Deployment" - spec: { - selector: matchLabels: { - "app.oam.dev/component": context.name - } - - template: { - metadata: labels: { - "app.oam.dev/component": context.name - } - - spec: { - containers: [{ - name: context.name - image: parameter.image - - if parameter["cmd"] != _|_ { - command: parameter.cmd - } - }] - } - } - } - } - parameter: { - // +usage=Which image would you like to use for your service - // +short=i - image: string - - // +usage=Commands to run in the container - cmd?: [...string] - } -` - var def v1beta1.ComponentDefinition - Expect(yaml.Unmarshal([]byte(validComponentDefinition), &def)).Should(BeNil()) - def.Namespace = namespace - Expect(k8sClient.Create(ctx, &def)).Should(Succeed()) - reconcileRetry(&r, req) - By("Check whether WorkloadDefinition is created") - - var wd v1beta1.WorkloadDefinition - var wdName = componentDefinitionName - Eventually(func() bool { - err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd) - return err == nil - }, 10*time.Second, time.Second).Should(BeTrue()) - Expect(wd.Name).Should(Equal(def.Name)) - Expect(wd.Namespace).Should(Equal(def.Namespace)) - Expect(wd.Annotations).Should(Equal(def.Annotations)) - Expect(wd.Spec.Schematic).Should(Equal(def.Spec.Schematic)) - }) - }) - - Context("When the ComponentDefinition contains Helm schematic", func() { - var componentDefinitionName = "cd-with-helm-schematic" - var namespace = "default" - req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}} - - It("Applying ComponentDefinition with Helm schematic", func() { - cd := v1beta1.ComponentDefinition{} - cd.SetName(componentDefinitionName) - cd.SetNamespace(namespace) - cd.Spec.Workload.Definition = common.WorkloadGVK{APIVersion: "apps/v1", Kind: "Deployment"} - cd.Spec.Schematic = &common.Schematic{ - HELM: &common.Helm{ - Release: util.Object2RawExtension(map[string]interface{}{ - "chart": map[string]interface{}{ - "spec": map[string]interface{}{ - "chart": "podinfo", - "version": "5.1.4", - }, - }, - }), - Repository: util.Object2RawExtension(map[string]interface{}{ - "url": "http://oam.dev/catalog/", - }), - }, - } - By("Create ComponentDefinition") - Expect(k8sClient.Create(ctx, &cd)).Should(Succeed()) - reconcileRetry(&r, req) - - By("Check whether WorkloadDefinition is created") - var wd v1beta1.WorkloadDefinition - var wdName = componentDefinitionName - Eventually(func() bool { - err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd) - return err == nil - }, 10*time.Second, time.Second).Should(BeTrue()) - Expect(wd.Name).Should(Equal(cd.Name)) - Expect(wd.Namespace).Should(Equal(cd.Namespace)) - Expect(wd.Annotations).Should(Equal(cd.Annotations)) - Expect(wd.Spec.Schematic).Should(Equal(cd.Spec.Schematic)) - }) - }) - - Context("When the ComponentDefinition contain Workload.Type, shouldn't create a WorkloadDefinition", func() { - var componentDefinitionName = "cd-with-workload-type" - var namespace = "default" - req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinitionName, Namespace: namespace}} - - It("Applying ComponentDefinition with Workload.Type", func() { - By("Apply WorkloadDefinition") - var taskWorkloadDefinition = ` -apiVersion: core.oam.dev/v1beta1 -kind: WorkloadDefinition -metadata: - name: worker - annotations: - definition.oam.dev/description: "Describes long-running, scalable, containerized services that running at backend. They do NOT have network endpoint to receive external network traffic." -spec: - definitionRef: - name: deployments.apps - schematic: - cue: - template: | - output: { - apiVersion: "apps/v1" - kind: "Deployment" - spec: { - selector: matchLabels: { - "app.oam.dev/component": context.name - } - - template: { - metadata: labels: { - "app.oam.dev/component": context.name - } - - spec: { - containers: [{ - name: context.name - image: parameter.image - - if parameter["cmd"] != _|_ { - command: parameter.cmd - } - }] - } - } - } - } - - parameter: { - // +usage=Which image would you like to use for your service - // +short=i - image: string - // +usage=Commands to run in the container - cmd?: [...string] - } -` - var task v1beta1.WorkloadDefinition - Expect(yaml.Unmarshal([]byte(taskWorkloadDefinition), &task)).Should(BeNil()) - task.Namespace = namespace - Expect(k8sClient.Create(ctx, &task)).Should(Succeed()) - - By("Apply ComponentDefinition") - var validComponentDefinition = ` -apiVersion: core.oam.dev/v1beta1 -kind: ComponentDefinition -metadata: - name: cd-with-workload-type -spec: - workload: - type: worker -` - var def v1beta1.ComponentDefinition - Expect(yaml.Unmarshal([]byte(validComponentDefinition), &def)).Should(BeNil()) - def.Namespace = namespace - Expect(k8sClient.Create(ctx, &def)).Should(Succeed()) - - By("Check whether WorkloadDefinition is created") - reconcileRetry(&r, req) - var wd v1beta1.WorkloadDefinition - var wdName = componentDefinitionName - Expect(k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd)).Should(Not(Succeed())) - - By("Check whether ConfigMap is created") - var cm corev1.ConfigMap - name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinitionName) - Eventually(func() bool { - err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm) - return err == nil - }, 15*time.Second, time.Second).Should(BeTrue()) - Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal(""))) - - By("Check whether ConfigMapRef refer to right") - Eventually(func() string { - _ = k8sClient.Get(ctx, client.ObjectKey{Namespace: def.Namespace, Name: def.Name}, &def) - return def.Status.ConfigMapRef - }, 10*time.Second, time.Second).Should(Equal(name)) - }) - }) - Context("When the CUE Template in ComponentDefinition import new added CRD", func() { var componentDefinationName = "test-refresh" var namespace = "default" @@ -699,24 +573,38 @@ spec: Expect(k8sClient.Create(ctx, &cd)).Should(Succeed()) req := reconcile.Request{NamespacedName: client.ObjectKey{Name: componentDefinationName, Namespace: namespace}} - By("check workload") - var wd v1beta1.WorkloadDefinition - var wdName = componentDefinationName - Eventually(func() bool { - reconcileRetry(&r, req) - err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: wdName}, &wd) - return err == nil - }, 30*time.Second, time.Second).Should(BeTrue()) - By("Check whether ConfigMap is created") var cm corev1.ConfigMap name := fmt.Sprintf("%s%s", types.CapabilityConfigMapNamePrefix, componentDefinationName) Eventually(func() bool { + reconcileRetry(&r, req) err := k8sClient.Get(ctx, client.ObjectKey{Namespace: namespace, Name: name}, &cm) return err == nil - }, 15*time.Second, time.Second).Should(BeTrue()) + }, 30*time.Second, time.Second).Should(BeTrue()) Expect(cm.Data[types.OpenapiV3JSONSchema]).Should(Not(Equal(""))) }) }) }) + +func generateTemplate(template string) runtime.RawExtension { + b, _ := yaml.YAMLToJSON([]byte(template)) + return runtime.RawExtension{Raw: b} +} + +var KUBEWorkerTemplate = `apiVersion: apps/v1 +kind: Deployment +spec: + selector: + matchLabels: + app: nginx + template: + metadata: + labels: + app: nginx + spec: + containers: + - name: nginx + ports: + - containerPort: 80 +` diff --git a/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/handler.go b/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/handler.go deleted file mode 100644 index 92f82fb4e..000000000 --- a/pkg/controller/core.oam.dev/v1alpha2/core/components/componentdefinition/handler.go +++ /dev/null @@ -1,84 +0,0 @@ -/* - Copyright 2021. The KubeVela Authors. - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. -*/ - -package componentdefinition - -import ( - "context" - "fmt" - - kerrors "k8s.io/apimachinery/pkg/api/errors" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/klog/v2" - "k8s.io/utils/pointer" - "sigs.k8s.io/controller-runtime/pkg/client" - - "github.com/oam-dev/kubevela/apis/core.oam.dev/common" - "github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1" - "github.com/oam-dev/kubevela/pkg/oam/discoverymapper" - "github.com/oam-dev/kubevela/pkg/oam/util" -) - -type handler struct { - client.Client - dm discoverymapper.DiscoveryMapper - cd *v1beta1.ComponentDefinition -} - -func (h *handler) CreateWorkloadDefinition(ctx context.Context) (util.WorkloadType, error) { - var workloadType = util.ComponentDef - var workloadName = h.cd.Name - if h.cd.Spec.Workload.Type != "" && h.cd.Spec.Workload.Definition == (common.WorkloadGVK{}) { - workloadType = util.ReferWorkload - workloadName = h.cd.Spec.Workload.Type - } - if h.cd.Spec.Schematic != nil && h.cd.Spec.Schematic.HELM != nil { - workloadType = util.HELMDef - } - if h.cd.Spec.Schematic != nil && h.cd.Spec.Schematic.KUBE != nil { - workloadType = util.KubeDef - } - - wd := new(v1beta1.WorkloadDefinition) - err := h.Get(ctx, client.ObjectKey{Namespace: h.cd.Namespace, Name: workloadName}, wd) - if err != nil { - switch workloadType { - case util.ReferWorkload: - klog.Infof("ComponentDefinition %s refer to wrong Workload", h.cd.Name) - return workloadType, err - default: - if !kerrors.IsNotFound(err) { - return workloadType, err - } - newCd := h.cd.DeepCopy() - if err := util.ConvertComponentDef2WorkloadDef(h.dm, newCd, wd); err != nil { - return workloadType, fmt.Errorf("convert WorkloadDefinition %s error %w", h.cd.Name, err) - } - owners := []metav1.OwnerReference{{ - APIVersion: v1beta1.SchemeGroupVersion.String(), - Kind: v1beta1.ComponentDefinitionKind, - Name: h.cd.Name, - UID: h.cd.UID, - Controller: pointer.BoolPtr(true), - }} - wd.SetOwnerReferences(owners) - if err := h.Create(ctx, wd); err != nil { - return workloadType, fmt.Errorf("create converted WorkloadDefinition %s error %w", h.cd.Name, err) - } - } - } - return workloadType, nil -} diff --git a/pkg/controller/utils/capability.go b/pkg/controller/utils/capability.go index e03d1e883..f09e477e1 100644 --- a/pkg/controller/utils/capability.go +++ b/pkg/controller/utils/capability.go @@ -34,7 +34,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" commontypes "github.com/oam-dev/kubevela/apis/core.oam.dev/common" - "github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2" "github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1" "github.com/oam-dev/kubevela/apis/types" "github.com/oam-dev/kubevela/pkg/appfile" @@ -67,6 +66,26 @@ type CapabilityComponentDefinition struct { CapabilityBaseDefinition } +// NewCapabilityComponentDef will create a CapabilityComponentDefinition +func NewCapabilityComponentDef(componentDefinition *v1beta1.ComponentDefinition) CapabilityComponentDefinition { + var def CapabilityComponentDefinition + def.Name = componentDefinition.Name + if componentDefinition.Spec.Workload.Definition == (commontypes.WorkloadGVK{}) && componentDefinition.Spec.Workload.Type != "" { + def.WorkloadType = util.ReferWorkload + def.WorkloadDefName = componentDefinition.Spec.Workload.Type + } + if componentDefinition.Spec.Schematic != nil && componentDefinition.Spec.Schematic.HELM != nil { + def.WorkloadType = util.HELMDef + def.Helm = componentDefinition.Spec.Schematic.HELM + } + if componentDefinition.Spec.Schematic != nil && componentDefinition.Spec.Schematic.KUBE != nil { + def.WorkloadType = util.KubeDef + def.Kube = componentDefinition.Spec.Schematic.KUBE + } + def.ComponentDefinition = *componentDefinition.DeepCopy() + return def +} + // GetCapabilityObject gets types.Capability object by WorkloadDefinition name func (def *CapabilityComponentDefinition) GetCapabilityObject(ctx context.Context, k8sClient client.Client, namespace, name string) (*types.Capability, error) { var componentDefinition v1beta1.ComponentDefinition @@ -81,20 +100,11 @@ func (def *CapabilityComponentDefinition) GetCapabilityObject(ctx context.Contex } def.ComponentDefinition = componentDefinition - switch def.WorkloadType { - case util.ReferWorkload: - var wd = new(v1alpha2.WorkloadDefinition) - objectKey.Name = def.WorkloadDefName - if err := k8sClient.Get(ctx, objectKey, wd); err != nil { - return nil, fmt.Errorf("failed to get WorkloadDefinition that ComponentDefinition refers to") - } - capability, err = appfile.ConvertTemplateJSON2Object(name, wd.Spec.Extension, wd.Spec.Schematic) - default: - capability, err = appfile.ConvertTemplateJSON2Object(name, componentDefinition.Spec.Extension, componentDefinition.Spec.Schematic) - if err != nil { - return nil, fmt.Errorf("failed to convert ComponentDefinition to Capability Object") - } + capability, err = appfile.ConvertTemplateJSON2Object(name, componentDefinition.Spec.Extension, componentDefinition.Spec.Schematic) + if err != nil { + return nil, fmt.Errorf("failed to convert ComponentDefinition to Capability Object") } + return &capability, err } diff --git a/test/e2e-test/app_embed_rollout_test.go b/test/e2e-test/app_embed_rollout_test.go index 5931ff2b7..9b3a71851 100644 --- a/test/e2e-test/app_embed_rollout_test.go +++ b/test/e2e-test/app_embed_rollout_test.go @@ -127,6 +127,11 @@ var _ = Describe("Cloneset based app embed rollout tests", func() { AfterEach(func() { By("Clean up resources after a test") + k8sClient.DeleteAllOf(ctx, &v1beta1.Application{}, client.InNamespace(namespaceName)) + k8sClient.DeleteAllOf(ctx, &v1beta1.ComponentDefinition{}, client.InNamespace(namespaceName)) + k8sClient.DeleteAllOf(ctx, &v1beta1.WorkloadDefinition{}, client.InNamespace(namespaceName)) + k8sClient.DeleteAllOf(ctx, &v1beta1.TraitDefinition{}, client.InNamespace(namespaceName)) + By(fmt.Sprintf("Delete the entire namespaceName %s", ns.Name)) // delete the namespaceName with all its resources Expect(k8sClient.Delete(ctx, &ns, client.PropagationPolicy(metav1.DeletePropagationBackground))).Should(BeNil()) diff --git a/test/e2e-test/app_resourcetracker_test.go b/test/e2e-test/app_resourcetracker_test.go index efd710898..dbdba069d 100644 --- a/test/e2e-test/app_resourcetracker_test.go +++ b/test/e2e-test/app_resourcetracker_test.go @@ -67,6 +67,11 @@ var _ = Describe("Test application cross namespace resource", func() { AfterEach(func() { By("Clean up resources after a test") + k8sClient.DeleteAllOf(ctx, &v1beta1.Application{}, client.InNamespace(namespace)) + k8sClient.DeleteAllOf(ctx, &v1beta1.ComponentDefinition{}, client.InNamespace(namespace)) + k8sClient.DeleteAllOf(ctx, &v1beta1.WorkloadDefinition{}, client.InNamespace(namespace)) + k8sClient.DeleteAllOf(ctx, &v1beta1.TraitDefinition{}, client.InNamespace(namespace)) + Expect(k8sClient.Delete(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}, client.PropagationPolicy(metav1.DeletePropagationForeground))).Should(Succeed()) Expect(k8sClient.Delete(ctx, &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: crossNamespace}}, client.PropagationPolicy(metav1.DeletePropagationForeground))).Should(Succeed()) // guarantee namespace have been deleted diff --git a/test/e2e-test/app_revision_clean_up_test.go b/test/e2e-test/app_revision_clean_up_test.go index 0407a6051..df3f022b6 100644 --- a/test/e2e-test/app_revision_clean_up_test.go +++ b/test/e2e-test/app_revision_clean_up_test.go @@ -65,6 +65,11 @@ var _ = Describe("Test application controller clean up appRevision", func() { AfterEach(func() { By("[TEST] Clean up resources after an integration test") + k8sClient.DeleteAllOf(ctx, &v1beta1.Application{}, client.InNamespace(namespace)) + k8sClient.DeleteAllOf(ctx, &v1beta1.ComponentDefinition{}, client.InNamespace(namespace)) + k8sClient.DeleteAllOf(ctx, &v1beta1.WorkloadDefinition{}, client.InNamespace(namespace)) + k8sClient.DeleteAllOf(ctx, &v1beta1.TraitDefinition{}, client.InNamespace(namespace)) + Expect(k8sClient.Delete(ctx, &v1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}, client.PropagationPolicy(metav1.DeletePropagationForeground))).Should(Succeed()) // guarantee namespace have been deleted Eventually(func() error { diff --git a/test/e2e-test/definition_revision_test.go b/test/e2e-test/definition_revision_test.go index d2c0bf65c..27d4dabda 100644 --- a/test/e2e-test/definition_revision_test.go +++ b/test/e2e-test/definition_revision_test.go @@ -81,7 +81,7 @@ var _ = Describe("Test application of the specified definition version", func() return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(labelDefRevList.Items)) } return nil - }, 40*time.Second, time.Second).Should(BeNil()) + }, 60*time.Second, time.Second).Should(BeNil()) }) @@ -144,7 +144,7 @@ var _ = Describe("Test application of the specified definition version", func() return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(workerDefRevList.Items)) } return nil - }, 40*time.Second, time.Second).Should(BeNil()) + }, 60*time.Second, time.Second).Should(BeNil()) webserviceV1 := webServiceWithNoTemplate.DeepCopy() webserviceV1.Spec.Schematic.CUE.Template = webServiceV1Template @@ -175,7 +175,7 @@ var _ = Describe("Test application of the specified definition version", func() return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(webserviceDefRevList.Items)) } return nil - }, 40*time.Second, time.Second).Should(BeNil()) + }, 60*time.Second, time.Second).Should(BeNil()) app := v1beta1.Application{ ObjectMeta: metav1.ObjectMeta{ @@ -406,7 +406,7 @@ var _ = Describe("Test application of the specified definition version", func() return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(helmworkerDefRevList.Items)) } return nil - }, 40*time.Second, time.Second).Should(BeNil()) + }, 60*time.Second, time.Second).Should(BeNil()) app := v1beta1.Application{ ObjectMeta: metav1.ObjectMeta{ @@ -586,7 +586,7 @@ var _ = Describe("Test application of the specified definition version", func() return fmt.Errorf("error defRevison number wants %d, actually %d", 2, len(kubeworkerDefRevList.Items)) } return nil - }, 40*time.Second, time.Second).Should(BeNil()) + }, 60*time.Second, time.Second).Should(BeNil()) app := v1beta1.Application{ ObjectMeta: metav1.ObjectMeta{ diff --git a/test/e2e-test/definition_test.go b/test/e2e-test/definition_test.go index 269ba03f3..6adb0a56f 100644 --- a/test/e2e-test/definition_test.go +++ b/test/e2e-test/definition_test.go @@ -32,7 +32,7 @@ import ( "github.com/oam-dev/kubevela/pkg/oam/util" ) -var _ = Describe("Test application of the specified definition version", func() { +var _ = Describe("ComponentDefinition Normal tests", func() { ctx := context.Background() var namespace string @@ -59,7 +59,41 @@ var _ = Describe("Test application of the specified definition version", func() }) Context("Test dynamic admission control for componentDefinition", func() { - It("Test componentDefinition only set definition fields", func() { + + It("Test componentDefinition which only set type field", func() { + workDef := &v1beta1.WorkloadDefinition{ + TypeMeta: metav1.TypeMeta{ + Kind: "ComponentDefinition", + APIVersion: "core.oam.dev/v1beta1", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "deployments.apps", + }, + Spec: v1beta1.WorkloadDefinitionSpec{ + Reference: common.DefinitionReference{ + Name: "deployments.apps", + Version: "v1", + }, + }, + } + workDef.SetNamespace(namespace) + Expect(k8sClient.Create(ctx, workDef)).Should(BeNil()) + + cd := webServiceWithNoTemplate.DeepCopy() + cd.Spec.Workload.Definition = common.WorkloadGVK{} + cd.Spec.Workload.Type = "deployments.apps" + cd.SetNamespace(namespace) + cd.SetName("test-componentdef") + cd.Spec.Schematic.CUE.Template = webServiceV1Template + Expect(k8sClient.Create(ctx, cd)).Should(Succeed()) + + defRev := new(v1beta1.DefinitionRevision) + Eventually(func() error { + return k8sClient.Get(ctx, client.ObjectKey{Name: "test-componentdef-v1", Namespace: namespace}, defRev) + }).Should(BeNil()) + }) + + It("Test componentDefinition only set definition field", func() { testCd := webServiceWithNoTemplate.DeepCopy() testCd.Spec.Schematic.CUE.Template = webServiceV1Template testCd.SetName("test-componentdef-v1") @@ -86,30 +120,30 @@ var _ = Describe("Test application of the specified definition version", func() }) It("Test componentDefinition which definition and type fields are all empty", func() { - testCd := webServiceWithNoTemplate.DeepCopy() - testCd.SetName("test-componentdef-v2") - testCd.Spec.Workload.Definition = common.WorkloadGVK{} - testCd.Spec.Schematic.CUE.Template = webServiceV1Template - testCd.SetNamespace(namespace) - Expect(k8sClient.Create(ctx, testCd)).Should(HaveOccurred()) + testCd1 := webServiceWithNoTemplate.DeepCopy() + testCd1.SetName("test-componentdef-v2") + testCd1.Spec.Workload.Definition = common.WorkloadGVK{} + testCd1.Spec.Schematic.CUE.Template = webServiceV1Template + testCd1.SetNamespace(namespace) + Expect(k8sClient.Create(ctx, testCd1)).Should(HaveOccurred()) }) It("Test componentDefinition which definition and type point to same workload type", func() { - testCd := webServiceWithNoTemplate.DeepCopy() - testCd.SetName("test-componentdef-v3") - testCd.Spec.Workload.Type = "deployments.apps" - testCd.Spec.Schematic.CUE.Template = webServiceV1Template - testCd.SetNamespace(namespace) - Expect(k8sClient.Create(ctx, testCd)).Should(Succeed()) + testCd2 := webServiceWithNoTemplate.DeepCopy() + testCd2.SetName("test-componentdef-v3") + testCd2.Spec.Workload.Type = "deployments.apps" + testCd2.Spec.Schematic.CUE.Template = webServiceV1Template + testCd2.SetNamespace(namespace) + Expect(k8sClient.Create(ctx, testCd2)).Should(Succeed()) }) It("Test componentDefinition which definition and type point to different workload type", func() { - testCd := webServiceWithNoTemplate.DeepCopy() - testCd.SetName("test-componentdef-v4") - testCd.Spec.Workload.Type = "jobs.batch" - testCd.Spec.Schematic.CUE.Template = webServiceV1Template - testCd.SetNamespace(namespace) - Expect(k8sClient.Create(ctx, testCd)).Should(HaveOccurred()) + testCd3 := webServiceWithNoTemplate.DeepCopy() + testCd3.SetName("test-componentdef-v4") + testCd3.Spec.Workload.Type = "jobs.batch" + testCd3.Spec.Schematic.CUE.Template = webServiceV1Template + testCd3.SetNamespace(namespace) + Expect(k8sClient.Create(ctx, testCd3)).Should(HaveOccurred()) }) }) })