Fix: fix the goroutine leak in http request (#4302)

Signed-off-by: FogDong <dongtianxin.tx@alibaba-inc.com>
(cherry picked from commit 559ef83abd)

Co-authored-by: FogDong <dongtianxin.tx@alibaba-inc.com>

charts/vela-core/templates/defwithtemplate/webservice.yaml

@@ -506,23 +506,49 @@ spec:
       import "strconv"
       ready: {
       	if context.output.status.readyReplicas == _|_ {
-      		replica: "0"
+      		readyReplicas: 0
       	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  strconv.FormatInt(context.output.status.readyReplicas, 10)
+      		readyReplicas: context.output.status.readyReplicas
       	}
       }
-      message: "Ready:" + ready.replica + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
+
+      message: "Ready:" + strconv.FormatInt(ready.readyReplicas, 10) + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
     healthPolicy: |-
       ready: {
-      	if context.output.status.readyReplicas == _|_ {
-      		replica: 0
+      	if context.output.status.updatedReplicas == _|_  {
+      		updatedReplicas : 0
       	}
+
+      	if context.output.status.updatedReplicas != _|_  {
+      		updatedReplicas : context.output.status.updatedReplicas
+      	}
+
+      	if context.output.status.readyReplicas == _|_ {
+      		readyReplicas: 0
+      	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  context.output.status.readyReplicas
+      		readyReplicas: context.output.status.readyReplicas
+      	}
+
+      	if context.output.status.replicas == _|_ {
+      		replicas: 0
+      	}
+      	if context.output.status.replicas != _|_ {
+      		replicas: context.output.status.replicas
+      	}
+
+      	if context.output.status.observedGeneration != _|_ {
+      		observedGeneration: context.output.status.observedGeneration
+      	}
+
+      	if context.output.status.observedGeneration == _|_ {
+      		observedGeneration: 0
       	}
       }
-      isHealth: context.output.spec.replicas == ready.replica
+      	isHealth: (context.output.spec.replicas == ready.readyReplicas) && (context.output.spec.replicas == ready.updatedReplicas) && (context.output.spec.replicas == ready.replicas) && (ready.observedGeneration == context.output.metadata.generation || ready.observedGeneration > context.output.metadata.generation)
   workload:
     definition:
       apiVersion: apps/v1

charts/vela-core/templates/defwithtemplate/worker.yaml

@@ -399,23 +399,49 @@ spec:
       import "strconv"
       ready: {
       	if context.output.status.readyReplicas == _|_ {
-      		replica: "0"
+      		readyReplicas: 0
       	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  strconv.FormatInt(context.output.status.readyReplicas, 10)
+      		readyReplicas: context.output.status.readyReplicas
       	}
       }
-      message: "Ready:" + ready.replica + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
+
+      message: "Ready:" + strconv.FormatInt(ready.readyReplicas, 10) + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
     healthPolicy: |-
       ready: {
-      	if context.output.status.readyReplicas == _|_ {
-      		replica: 0
+      	if context.output.status.updatedReplicas == _|_  {
+      		updatedReplicas : 0
       	}
+
+      	if context.output.status.updatedReplicas != _|_  {
+      		updatedReplicas : context.output.status.updatedReplicas
+      	}
+
+      	if context.output.status.readyReplicas == _|_ {
+      		readyReplicas: 0
+      	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  context.output.status.readyReplicas
+      		readyReplicas: context.output.status.readyReplicas
+      	}
+
+      	if context.output.status.replicas == _|_ {
+      		replicas: 0
+      	}
+      	if context.output.status.replicas != _|_ {
+      		replicas: context.output.status.replicas
+      	}
+
+      	if context.output.status.observedGeneration != _|_ {
+      		observedGeneration: context.output.status.observedGeneration
+      	}
+
+      	if context.output.status.observedGeneration == _|_ {
+      		observedGeneration: 0
       	}
       }
-      isHealth: context.output.spec.replicas == ready.replica
+      	isHealth: (context.output.spec.replicas == ready.readyReplicas) && (context.output.spec.replicas == ready.updatedReplicas) && (context.output.spec.replicas == ready.replicas) && (ready.observedGeneration == context.output.metadata.generation || ready.observedGeneration > context.output.metadata.generation)
   workload:
     definition:
       apiVersion: apps/v1

charts/vela-core/templates/kubevela-controller.yaml

@@ -135,7 +135,7 @@ spec:
             - "--application-re-sync-period={{ .Values.controllerArgs.reSyncPeriod }}"
             - "--concurrent-reconciles={{ .Values.concurrentReconciles }}"
             - "--kube-api-qps={{ .Values.kubeClient.qps }}"
-            - "--kube-api-burst={{ .Values.kubeClient.brust }}"
+            - "--kube-api-burst={{ .Values.kubeClient.burst }}"
           image: {{ .Values.imageRegistry }}{{ .Values.image.repository }}:{{ .Values.image.tag }}
           imagePullPolicy: {{ quote .Values.image.pullPolicy }}
           resources:

charts/vela-core/templates/test/test-application.yaml

@@ -29,7 +29,7 @@ metadata:
     "helm.sh/hook": test
     helm.sh/hook-delete-policy: hook-succeeded
 spec:
-  serviceAccountName: kubevela-vela-core
+  serviceAccountName: {{ include "kubevela.serviceAccountName" . }}
   containers:
     - name: {{ .Release.Name }}-application-test
       image: {{ .Values.imageRegistry }}{{ .Values.test.k8s.repository }}:{{ .Values.test.k8s.tag }}

charts/vela-core/values.yaml

@@ -103,7 +103,7 @@ kubeClient:
   # the qps for reconcile clients, default is 50
   qps: 50
   # the burst for reconcile clients, default is 100
-  brust: 100
+  burst: 100
 
 # dependCheckWait is the time to wait for ApplicationConfiguration's dependent-resource ready
 dependCheckWait: 30s

charts/vela-minimal/templates/defwithtemplate/webservice.yaml

@@ -506,23 +506,49 @@ spec:
       import "strconv"
       ready: {
       	if context.output.status.readyReplicas == _|_ {
-      		replica: "0"
+      		readyReplicas: 0
       	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  strconv.FormatInt(context.output.status.readyReplicas, 10)
+      		readyReplicas: context.output.status.readyReplicas
       	}
       }
-      message: "Ready:" + ready.replica + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
+
+      message: "Ready:" + strconv.FormatInt(ready.readyReplicas, 10) + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
     healthPolicy: |-
       ready: {
-      	if context.output.status.readyReplicas == _|_ {
-      		replica: 0
+      	if context.output.status.updatedReplicas == _|_  {
+      		updatedReplicas : 0
       	}
+
+      	if context.output.status.updatedReplicas != _|_  {
+      		updatedReplicas : context.output.status.updatedReplicas
+      	}
+
+      	if context.output.status.readyReplicas == _|_ {
+      		readyReplicas: 0
+      	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  context.output.status.readyReplicas
+      		readyReplicas: context.output.status.readyReplicas
+      	}
+
+      	if context.output.status.replicas == _|_ {
+      		replicas: 0
+      	}
+      	if context.output.status.replicas != _|_ {
+      		replicas: context.output.status.replicas
+      	}
+
+      	if context.output.status.observedGeneration != _|_ {
+      		observedGeneration: context.output.status.observedGeneration
+      	}
+
+      	if context.output.status.observedGeneration == _|_ {
+      		observedGeneration: 0
       	}
       }
-      isHealth: context.output.spec.replicas == ready.replica
+      	isHealth: (context.output.spec.replicas == ready.readyReplicas) && (context.output.spec.replicas == ready.updatedReplicas) && (context.output.spec.replicas == ready.replicas) && (ready.observedGeneration == context.output.metadata.generation || ready.observedGeneration > context.output.metadata.generation)
   workload:
     definition:
       apiVersion: apps/v1

charts/vela-minimal/templates/defwithtemplate/worker.yaml

@@ -399,23 +399,49 @@ spec:
       import "strconv"
       ready: {
       	if context.output.status.readyReplicas == _|_ {
-      		replica: "0"
+      		readyReplicas: 0
       	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  strconv.FormatInt(context.output.status.readyReplicas, 10)
+      		readyReplicas: context.output.status.readyReplicas
       	}
       }
-      message: "Ready:" + ready.replica + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
+
+      message: "Ready:" + strconv.FormatInt(ready.readyReplicas, 10) + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
     healthPolicy: |-
       ready: {
-      	if context.output.status.readyReplicas == _|_ {
-      		replica: 0
+      	if context.output.status.updatedReplicas == _|_  {
+      		updatedReplicas : 0
       	}
+
+      	if context.output.status.updatedReplicas != _|_  {
+      		updatedReplicas : context.output.status.updatedReplicas
+      	}
+
+      	if context.output.status.readyReplicas == _|_ {
+      		readyReplicas: 0
+      	}
+
       	if context.output.status.readyReplicas != _|_ {
-      		replica:  context.output.status.readyReplicas
+      		readyReplicas: context.output.status.readyReplicas
+      	}
+
+      	if context.output.status.replicas == _|_ {
+      		replicas: 0
+      	}
+      	if context.output.status.replicas != _|_ {
+      		replicas: context.output.status.replicas
+      	}
+
+      	if context.output.status.observedGeneration != _|_ {
+      		observedGeneration: context.output.status.observedGeneration
+      	}
+
+      	if context.output.status.observedGeneration == _|_ {
+      		observedGeneration: 0
       	}
       }
-      isHealth: context.output.spec.replicas == ready.replica
+      	isHealth: (context.output.spec.replicas == ready.readyReplicas) && (context.output.spec.replicas == ready.updatedReplicas) && (context.output.spec.replicas == ready.replicas) && (ready.observedGeneration == context.output.metadata.generation || ready.observedGeneration > context.output.metadata.generation)
   workload:
     definition:
       apiVersion: apps/v1

charts/vela-minimal/templates/kubevela-controller.yaml

@@ -138,7 +138,7 @@ spec:
             {{ end }}
             - "--concurrent-reconciles={{ .Values.concurrentReconciles }}"
             - "--kube-api-qps={{ .Values.kubeClient.qps }}"
-            - "--kube-api-burst={{ .Values.kubeClient.brust }}"
+            - "--kube-api-burst={{ .Values.kubeClient.burst }}"
           image: {{ .Values.imageRegistry }}{{ .Values.image.repository }}:{{ .Values.image.tag }}
           imagePullPolicy: {{ quote .Values.image.pullPolicy }}
           resources:

charts/vela-minimal/values.yaml

@@ -109,7 +109,7 @@ kubeClient:
   # the qps for reconcile clients, default is 50
   qps: 50
   # the burst for reconcile clients, default is 100
-  brust: 100
+  burst: 100
 
 multicluster:
   enabled: false

go.mod

@@ -134,7 +134,7 @@ require (
 	github.com/cyphar/filepath-securejoin v0.2.2 // indirect
 	github.com/deislabs/oras v0.11.1 // indirect
 	github.com/docker/cli v20.10.5+incompatible // indirect
-	github.com/docker/distribution v2.7.1+incompatible // indirect
+	github.com/docker/distribution v2.8.0-beta.1+incompatible // indirect
 	github.com/docker/docker v17.12.0-ce-rc1.0.20200618181300-9dc6525e6118+incompatible // indirect
 	github.com/docker/docker-credential-helpers v0.6.3 // indirect
 	github.com/docker/go-connections v0.4.0 // indirect

go.sum

@@ -409,8 +409,9 @@ github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyG
 github.com/docker/cli v20.10.9+incompatible h1:OJ7YkwQA+k2Oi51lmCojpjiygKpi76P7bg91b2eJxYU=
 github.com/docker/cli v20.10.9+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
 github.com/docker/distribution v0.0.0-20191216044856-a8371794149d/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY=
-github.com/docker/distribution v2.7.1+incompatible h1:a5mlkVzth6W5A4fOsS3D2EO5BUmsJpcB+cRlLU7cSug=
 github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
+github.com/docker/distribution v2.8.0-beta.1+incompatible h1:9MjVa+OTMHm4C0kKZB68jPlDM9Cg75ta4i46Gxxxn8o=
+github.com/docker/distribution v2.8.0-beta.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/docker-credential-helpers v0.6.3 h1:zI2p9+1NQYdnG6sMU26EX4aVGlqbInSQxQXLvzJ4RPQ=
 github.com/docker/docker-credential-helpers v0.6.3/go.mod h1:WRaJzqw3CTB9bk10avuGsjVBZsD05qeibJ1/TYlvc0Y=
 github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=

pkg/addon/addon.go

@@ -89,7 +89,7 @@ const (
 )
 
 // ParameterFileName is the addon resources/parameter.cue file name
-var ParameterFileName = filepath.Join("resources", "parameter.cue")
+var ParameterFileName = strings.Join([]string{"resources", "parameter.cue"}, "/")
 
 // ListOptions contains flags mark what files should be read in an addon directory
 type ListOptions struct {
@@ -182,7 +182,7 @@ var Patterns = []Pattern{{Value: ReadmeFileName}, {Value: MetadataFileName}, {Va
 func GetPatternFromItem(it Item, r AsyncReader, rootPath string) string {
 	relativePath := r.RelativePath(it)
 	for _, p := range Patterns {
-		if strings.HasPrefix(relativePath, filepath.Join(rootPath, p.Value)) {
+		if strings.HasPrefix(relativePath, strings.Join([]string{rootPath, p.Value}, "/")) {
 			return p.Value
 		}
 	}

pkg/appfile/appfile.go

@@ -224,7 +224,8 @@ func (af *Appfile) PrepareWorkflowAndPolicy(ctx context.Context) ([]*unstructure
 }
 
 func (af *Appfile) generateUnstructured(workload *Workload) (*unstructured.Unstructured, error) {
-	un, err := generateUnstructuredFromCUEModule(workload, af.Name, af.AppRevisionName, af.Namespace, af.Components, af.Artifacts)
+	ctxData := GenerateContextDataFromAppFile(af, workload.Name)
+	un, err := generateUnstructuredFromCUEModule(workload, af.Artifacts, ctxData)
 	if err != nil {
 		return nil, err
 	}
@@ -235,13 +236,13 @@ func (af *Appfile) generateUnstructured(workload *Workload) (*unstructured.Unstr
 	return un, nil
 }
 
-func generateUnstructuredFromCUEModule(wl *Workload, appName, revision, ns string, components []common.ApplicationComponent, artifacts []*types.ComponentManifest) (*unstructured.Unstructured, error) {
-	pCtx := process.NewPolicyContext(ns, wl.Name, appName, revision, components)
+func generateUnstructuredFromCUEModule(wl *Workload, artifacts []*types.ComponentManifest, ctxData process.ContextData) (*unstructured.Unstructured, error) {
+	pCtx := process.NewContext(ctxData)
 	pCtx.PushData(model.ContextDataArtifacts, prepareArtifactsData(artifacts))
 	if err := wl.EvalContext(pCtx); err != nil {
-		return nil, errors.Wrapf(err, "evaluate base template app=%s in namespace=%s", appName, ns)
+		return nil, errors.Wrapf(err, "evaluate base template app=%s in namespace=%s", ctxData.AppName, ctxData.Namespace)
 	}
-	return makeWorkloadWithContext(pCtx, wl, ns, appName)
+	return makeWorkloadWithContext(pCtx, wl, ctxData.Namespace, ctxData.AppName)
 }
 
 // artifacts contains resources in unstructured shape of all components
@@ -292,17 +293,18 @@ func (af *Appfile) GenerateComponentManifest(wl *Workload) (*types.ComponentMani
 	if af.Namespace == "" {
 		af.Namespace = corev1.NamespaceDefault
 	}
+	ctxData := GenerateContextDataFromAppFile(af, wl.Name)
 	// generate context here to avoid nil pointer panic
-	wl.Ctx = NewBasicContext(af.Name, wl.Name, af.AppRevisionName, af.Namespace, wl.Params)
+	wl.Ctx = NewBasicContext(GenerateContextDataFromAppFile(af, wl.Name), wl.Params)
 	switch wl.CapabilityCategory {
 	case types.HelmCategory:
-		return generateComponentFromHelmModule(wl, af.Name, af.AppRevisionName, af.Namespace)
+		return generateComponentFromHelmModule(wl, ctxData)
 	case types.KubeCategory:
-		return generateComponentFromKubeModule(wl, af.Name, af.AppRevisionName, af.Namespace)
+		return generateComponentFromKubeModule(wl, ctxData)
 	case types.TerraformCategory:
 		return generateComponentFromTerraformModule(wl, af.Name, af.Namespace)
 	default:
-		return generateComponentFromCUEModule(wl, af.Name, af.AppRevisionName, af.Namespace)
+		return generateComponentFromCUEModule(wl, ctxData)
 	}
 }
 
@@ -471,31 +473,31 @@ func (af *Appfile) setWorkloadRefToTrait(wlRef corev1.ObjectReference, trait *un
 }
 
 // PrepareProcessContext prepares a DSL process Context
-func PrepareProcessContext(wl *Workload, applicationName, revision, namespace string) (process.Context, error) {
+func PrepareProcessContext(wl *Workload, ctxData process.ContextData) (process.Context, error) {
 	if wl.Ctx == nil {
-		wl.Ctx = NewBasicContext(applicationName, wl.Name, revision, namespace, wl.Params)
+		wl.Ctx = NewBasicContext(ctxData, wl.Params)
 	}
 	if err := wl.EvalContext(wl.Ctx); err != nil {
-		return nil, errors.Wrapf(err, "evaluate base template app=%s in namespace=%s", applicationName, namespace)
+		return nil, errors.Wrapf(err, "evaluate base template app=%s in namespace=%s", ctxData.AppName, ctxData.Namespace)
 	}
 	return wl.Ctx, nil
 }
 
 // NewBasicContext prepares a basic DSL process Context
-func NewBasicContext(applicationName, workloadName, revision, namespace string, params map[string]interface{}) process.Context {
-	pCtx := process.NewContext(namespace, workloadName, applicationName, revision)
+func NewBasicContext(contextData process.ContextData, params map[string]interface{}) process.Context {
+	pCtx := process.NewContext(contextData)
 	if params != nil {
 		pCtx.SetParameters(params)
 	}
 	return pCtx
 }
 
-func generateComponentFromCUEModule(wl *Workload, appName, revision, ns string) (*types.ComponentManifest, error) {
-	pCtx, err := PrepareProcessContext(wl, appName, revision, ns)
+func generateComponentFromCUEModule(wl *Workload, ctxData process.ContextData) (*types.ComponentManifest, error) {
+	pCtx, err := PrepareProcessContext(wl, ctxData)
 	if err != nil {
 		return nil, err
 	}
-	return baseGenerateComponent(pCtx, wl, appName, ns)
+	return baseGenerateComponent(pCtx, wl, ctxData.AppName, ctxData.Namespace)
 }
 
 func generateComponentFromTerraformModule(wl *Workload, appName, ns string) (*types.ComponentManifest, error) {
@@ -664,7 +666,7 @@ output: {
 	return templateStr, nil
 }
 
-func generateComponentFromKubeModule(wl *Workload, appName, revision, ns string) (*types.ComponentManifest, error) {
+func generateComponentFromKubeModule(wl *Workload, ctxData process.ContextData) (*types.ComponentManifest, error) {
 	templateStr, err := GenerateCUETemplate(wl)
 	if err != nil {
 		return nil, err
@@ -672,7 +674,7 @@ func generateComponentFromKubeModule(wl *Workload, appName, revision, ns string)
 	wl.FullTemplate.TemplateStr = templateStr
 
 	// re-use the way CUE module generates comp & acComp
-	compManifest, err := generateComponentFromCUEModule(wl, appName, revision, ns)
+	compManifest, err := generateComponentFromCUEModule(wl, ctxData)
 	if err != nil {
 		return nil, err
 	}
@@ -839,7 +841,7 @@ func setParameterValuesToKubeObj(obj *unstructured.Unstructured, values paramVal
 	return nil
 }
 
-func generateComponentFromHelmModule(wl *Workload, appName, revision, ns string) (*types.ComponentManifest, error) {
+func generateComponentFromHelmModule(wl *Workload, ctxData process.ContextData) (*types.ComponentManifest, error) {
 	templateStr, err := GenerateCUETemplate(wl)
 	if err != nil {
 		return nil, err
@@ -849,22 +851,38 @@ func generateComponentFromHelmModule(wl *Workload, appName, revision, ns string)
 	// re-use the way CUE module generates comp & acComp
 	compManifest := &types.ComponentManifest{
 		Name:             wl.Name,
-		Namespace:        ns,
+		Namespace:        ctxData.Namespace,
 		ExternalRevision: wl.ExternalRevision,
 		StandardWorkload: &unstructured.Unstructured{},
 	}
 
 	if wl.FullTemplate.Reference.Type != types.AutoDetectWorkloadDefinition {
-		compManifest, err = generateComponentFromCUEModule(wl, appName, revision, ns)
+		compManifest, err = generateComponentFromCUEModule(wl, ctxData)
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	rls, repo, err := helm.RenderHelmReleaseAndHelmRepo(wl.FullTemplate.Helm, wl.Name, appName, ns, wl.Params)
+	rls, repo, err := helm.RenderHelmReleaseAndHelmRepo(wl.FullTemplate.Helm, wl.Name, ctxData.AppName, ctxData.Namespace, wl.Params)
 	if err != nil {
 		return nil, err
 	}
 	compManifest.PackagedWorkloadResources = []*unstructured.Unstructured{rls, repo}
 	return compManifest, nil
 }
+
+// GenerateContextDataFromAppFile generates process context data from app file
+func GenerateContextDataFromAppFile(appfile *Appfile, wlName string) process.ContextData {
+	data := process.ContextData{
+		Namespace:       appfile.Namespace,
+		AppName:         appfile.Name,
+		CompName:        wlName,
+		AppRevisionName: appfile.AppRevisionName,
+		Components:      appfile.Components,
+	}
+	if appfile.AppAnnotations != nil {
+		data.WorkflowName = appfile.AppAnnotations[oam.AnnotationWorkflowName]
+		data.PublishVersion = appfile.AppAnnotations[oam.AnnotationPublishVersion]
+	}
+	return data
+}

pkg/appfile/appfile_test.go

@@ -43,6 +43,7 @@ import (
 	oamtypes "github.com/oam-dev/kubevela/apis/types"
 	"github.com/oam-dev/kubevela/pkg/cue/definition"
 	"github.com/oam-dev/kubevela/pkg/cue/model"
+	"github.com/oam-dev/kubevela/pkg/oam"
 	"github.com/oam-dev/kubevela/pkg/oam/util"
 )
 
@@ -873,7 +874,12 @@ variable "password" {
 			revision: "v1",
 		}
 
-		pCtx := NewBasicContext(args.appName, args.wl.Name, args.revision, ns, args.wl.Params)
+		ctxData := GenerateContextDataFromAppFile(&Appfile{
+			Name:            args.appName,
+			Namespace:       ns,
+			AppRevisionName: args.revision,
+		}, args.wl.Name)
+		pCtx := NewBasicContext(ctxData, args.wl.Params)
 		comp, err := evalWorkloadWithContext(pCtx, args.wl, ns, args.appName, compName)
 		Expect(comp.StandardWorkload).ShouldNot(BeNil())
 		Expect(comp.Name).Should(Equal(""))
@@ -1329,7 +1335,17 @@ func TestBaseGenerateComponent(t *testing.T) {
 	var ns = "test-ns"
 	var traitName = "mytrait"
 	var wlName = "my-wl-1"
-	pContext := NewBasicContext(appName, wlName, "rev-1", ns, nil)
+	var workflowName = "my-wf"
+	var publishVersion = "123"
+	ctxData := GenerateContextDataFromAppFile(&Appfile{
+		Name:      appName,
+		Namespace: ns,
+		AppAnnotations: map[string]string{
+			oam.AnnotationWorkflowName:   workflowName,
+			oam.AnnotationPublishVersion: publishVersion,
+		},
+	}, wlName)
+	pContext := NewBasicContext(ctxData, nil)
 	base := `
 	apiVersion: "apps/v1"
 	kind:       "Deployment"
@@ -1359,11 +1375,14 @@ if context.componentType == "stateless" {
 	}
 	name:                   context.name
 	envSourceContainerName: context.name
+  workflowName:           context.workflowName
+  publishVersion:         context.publishVersion
 }`,
 	}
 	wl := &Workload{Type: "stateful", Traits: []*Trait{tr}}
 	cm, err := baseGenerateComponent(pContext, wl, appName, ns)
 	assert.NilError(t, err)
 	assert.Equal(t, cm.Traits[0].Object["kind"], "StatefulSet")
-	assert.Equal(t, cm.Traits[0].Object["name"], wlName)
+	assert.Equal(t, cm.Traits[0].Object["workflowName"], workflowName)
+	assert.Equal(t, cm.Traits[0].Object["publishVersion"], publishVersion)
 }

pkg/appfile/validate.go

@@ -33,7 +33,8 @@ func (p *Parser) ValidateCUESchematicAppfile(a *Appfile) error {
 		if wl.CapabilityCategory != types.CUECategory {
 			continue
 		}
-		pCtx, err := newValidationProcessContext(wl, a.Name, a.AppRevisionName, a.Namespace)
+		ctxData := GenerateContextDataFromAppFile(a, wl.Name)
+		pCtx, err := newValidationProcessContext(wl, ctxData)
 		if err != nil {
 			return errors.WithMessagef(err, "cannot create the validation process context of app=%s in namespace=%s", a.Name, a.Namespace)
 		}
@@ -49,7 +50,7 @@ func (p *Parser) ValidateCUESchematicAppfile(a *Appfile) error {
 	return nil
 }
 
-func newValidationProcessContext(wl *Workload, appName, revisionName, ns string) (process.Context, error) {
+func newValidationProcessContext(wl *Workload, ctxData process.ContextData) (process.Context, error) {
 	baseHooks := []process.BaseHook{
 		// add more hook funcs here to validate CUE base
 	}
@@ -58,9 +59,11 @@ func newValidationProcessContext(wl *Workload, appName, revisionName, ns string)
 		validateAuxiliaryNameUnique(),
 	}
 
-	pCtx := process.NewContextWithHooks(ns, wl.Name, appName, revisionName, baseHooks, auxiliaryHooks)
+	ctxData.BaseHooks = baseHooks
+	ctxData.AuxiliaryHooks = auxiliaryHooks
+	pCtx := process.NewContext(ctxData)
 	if err := wl.EvalContext(pCtx); err != nil {
-		return nil, errors.Wrapf(err, "evaluate base template app=%s in namespace=%s", appName, ns)
+		return nil, errors.Wrapf(err, "evaluate base template app=%s in namespace=%s", ctxData.AppName, ctxData.Namespace)
 	}
 	return pCtx, nil
 }

pkg/appfile/validate_test.go

@@ -58,7 +58,13 @@ var _ = Describe("Test validate CUE schematic Appfile", func() {
 			},
 			engine: definition.NewWorkloadAbstractEngine("myweb", pd),
 		}
-		pCtx, err := newValidationProcessContext(wl, "myapp", "myapp-v1", "test-ns")
+
+		ctxData := GenerateContextDataFromAppFile(&Appfile{
+			Name:            "myapp",
+			Namespace:       "test-ns",
+			AppRevisionName: "myapp-v1",
+		}, wl.Name)
+		pCtx, err := newValidationProcessContext(wl, ctxData)
 		Expect(err).Should(BeNil())
 		Eventually(func() string {
 			for _, tr := range wl.Traits {

pkg/builtin/http/http.go

@@ -51,7 +51,7 @@ func (c *HTTPCmd) Run(meta *registry.Meta) (res interface{}, err error) {
 	var (
 		r      io.Reader
 		client = &http.Client{
-			Transport: &http.Transport{},
+			Transport: http.DefaultTransport,
 			Timeout:   time.Second * 3,
 		}
 	)

pkg/controller/core.oam.dev/v1alpha2/application/generator.go

@@ -32,6 +32,7 @@ import (
 	"github.com/oam-dev/kubevela/pkg/appfile"
 	"github.com/oam-dev/kubevela/pkg/controller/core.oam.dev/v1alpha2/application/assemble"
 	"github.com/oam-dev/kubevela/pkg/cue/model/value"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	"github.com/oam-dev/kubevela/pkg/monitor/metrics"
 	"github.com/oam-dev/kubevela/pkg/multicluster"
 	"github.com/oam-dev/kubevela/pkg/oam"
@@ -60,16 +61,19 @@ func (h *AppHandler) GenerateApplicationSteps(ctx context.Context,
 	appParser *appfile.Parser,
 	af *appfile.Appfile,
 	appRev *v1beta1.ApplicationRevision) ([]wfTypes.TaskRunner, error) {
+
 	handlerProviders := providers.NewProviders()
 	kube.Install(handlerProviders, h.r.Client, h.Dispatch, h.Delete)
 	oamProvider.Install(handlerProviders, app, h.applyComponentFunc(
 		appParser, appRev, af), h.renderComponentFunc(appParser, appRev, af))
 	http.Install(handlerProviders, h.r.Client, app.Namespace)
-	taskDiscover := tasks.NewTaskDiscover(handlerProviders, h.r.pd, h.r.Client, h.r.dm)
+	pCtx := process.NewContext(generateContextDataFromApp(app, appRev.Name))
+	taskDiscover := tasks.NewTaskDiscover(handlerProviders, h.r.pd, h.r.Client, h.r.dm, pCtx)
 	multiclusterProvider.Install(handlerProviders, h.r.Client, app)
 	terraformProvider.Install(handlerProviders, app, func(comp common.ApplicationComponent) (*appfile.Workload, error) {
 		return appParser.ParseWorkloadFromRevision(comp, appRev)
 	})
+
 	var tasks []wfTypes.TaskRunner
 	for _, step := range af.WorkflowSteps {
 		options := &wfTypes.GeneratorOptions{
@@ -290,3 +294,17 @@ func generateStepID(stepName string, wfStatus *common.WorkflowStatus) string {
 	}
 	return id
 }
+
+func generateContextDataFromApp(app *v1beta1.Application, appRev string) process.ContextData {
+	data := process.ContextData{
+		Namespace:       app.Namespace,
+		AppName:         app.Name,
+		CompName:        app.Name,
+		AppRevisionName: appRev,
+	}
+	if app.Annotations != nil {
+		data.WorkflowName = app.Annotations[oam.AnnotationWorkflowName]
+		data.PublishVersion = app.Annotations[oam.AnnotationPublishVersion]
+	}
+	return data
+}

pkg/controller/core.oam.dev/v1alpha2/core/scopes/healthscope/healthscope.go

@@ -439,8 +439,8 @@ func CUEBasedHealthCheck(ctx context.Context, c client.Client, wlRef WorkloadRef
 
 		switch wl.CapabilityCategory {
 		case oamtypes.TerraformCategory:
-			pCtx = af.NewBasicContext(appfile.Name, wl.Name, appfile.AppRevisionName, appfile.Namespace, wl.Params)
 			ctx := context.Background()
+			pCtx = af.NewBasicContext(af.GenerateContextDataFromAppFile(appfile, wl.Name), wl.Params)
 			var configuration terraformapi.Configuration
 			if err := c.Get(ctx, client.ObjectKey{Name: wl.Name, Namespace: ns}, &configuration); err != nil {
 				wlHealth.HealthStatus = StatusUnhealthy
@@ -454,7 +454,8 @@ func CUEBasedHealthCheck(ctx context.Context, c client.Client, wlRef WorkloadRef
 			wlHealth.Diagnosis = configuration.Status.Apply.Message
 			okToCheckTrait = true
 		default:
-			pCtx = process.NewProcessContextWithCtx(ctx, ns, wl.Name, appfile.Name, appfile.AppRevisionName)
+			pCtx = process.NewContext(af.GenerateContextDataFromAppFile(appfile, wl.Name))
+			pCtx.SetCtx(ctx)
 			if wl.CapabilityCategory != oamtypes.CUECategory {
 				templateStr, err := af.GenerateCUETemplate(wl)
 				if err != nil {

pkg/cue/definition/template_test.go

@@ -217,7 +217,12 @@ parameter: {
 	}
 
 	for _, v := range testCases {
-		ctx := process.NewContext("default", "test", "myapp", "myapp-v1")
+		ctx := process.NewContext(process.ContextData{
+			AppName:         "myapp",
+			CompName:        "test",
+			Namespace:       "default",
+			AppRevisionName: "myapp-v1",
+		})
 		wt := NewWorkloadAbstractEngine("testWorkload", &packages.PackageDiscover{})
 		err := wt.Complete(ctx, v.workloadTemplate, v.params)
 		hasError := err != nil
@@ -918,7 +923,12 @@ parameter: [string]: string`,
 	}
 
 `
-		ctx := process.NewContext("default", "test", "myapp", "myapp-v1")
+		ctx := process.NewContext(process.ContextData{
+			AppName:         "myapp",
+			CompName:        "test",
+			Namespace:       "default",
+			AppRevisionName: "myapp-v1",
+		})
 		wt := NewWorkloadAbstractEngine("-", &packages.PackageDiscover{})
 		if err := wt.Complete(ctx, baseTemplate, map[string]interface{}{
 			"replicas": 2,
@@ -1017,7 +1027,12 @@ outputs: service :{
 	}
 	for k, v := range testcases {
 		wd := NewWorkloadAbstractEngine(k, &packages.PackageDiscover{})
-		ctx := process.NewContext("default", k, "myapp", "myapp-v1")
+		ctx := process.NewContext(process.ContextData{
+			AppName:         "myapp",
+			CompName:        k,
+			Namespace:       "default",
+			AppRevisionName: "myapp-v1",
+		})
 		err := wd.Complete(ctx, v.template, map[string]interface{}{})
 		assert.NoError(t, err)
 		_, assists := ctx.Output()
@@ -1095,7 +1110,12 @@ outputs: abc :{
 	}
 	for k, v := range testcases {
 		td := NewTraitAbstractEngine(k, &packages.PackageDiscover{})
-		ctx := process.NewContext("default", k, "myapp", "myapp-v1")
+		ctx := process.NewContext(process.ContextData{
+			AppName:         "myapp",
+			CompName:        k,
+			Namespace:       "default",
+			AppRevisionName: "myapp-v1",
+		})
 		err := td.Complete(ctx, v.template, map[string]interface{}{})
 		assert.NoError(t, err)
 		_, assists := ctx.Output()

pkg/cue/model/keyword.go

@@ -35,6 +35,10 @@ const (
 	ContextAppRevisionNum = "appRevisionNum"
 	// ContextNamespace is the namespace of the app
 	ContextNamespace = "namespace"
+	// ContextPublishVersion is the publish version of the app
+	ContextPublishVersion = "publishVersion"
+	// ContextWorkflowName is the name of the workflow
+	ContextWorkflowName = "workflowName"
 	// OutputSecretName is used to store all secret names which are generated by cloud resource components
 	OutputSecretName = "outputSecretName"
 	// ContextCompRevisionName is the component revision name of context

pkg/cue/model/value/value.go

@@ -317,7 +317,7 @@ func (val *Value) LookupValue(paths ...string) (*Value, error) {
 func (val *Value) LookupByScript(script string) (*Value, error) {
 	var outputKey = "zz_output__"
 	script = strings.TrimSpace(script)
-	scriptFile, err := parser.ParseFile("-", script)
+	scriptFile, err := parser.ParseFile("-", script, parser.ParseComments)
 	if err != nil {
 		return nil, errors.WithMessage(err, "parse script")
 	}
@@ -327,7 +327,7 @@ func (val *Value) LookupByScript(script string) (*Value, error) {
 		return nil, err
 	}
 
-	rawFile, err := parser.ParseFile("-", raw)
+	rawFile, err := parser.ParseFile("-", raw, parser.ParseComments)
 	if err != nil {
 		return nil, errors.WithMessage(err, "parse script")
 	}

pkg/cue/model/value/value_test.go

@@ -597,6 +597,23 @@ func TestLookupByScript(t *testing.T) {
 	}{
 		{
 			src: `
+traits: {
+	ingress: {
+		// +patchKey=name
+		test: [{name: "main", image: "busybox"}]
+	}
+}
+`,
+			script: `traits["ingress"]`,
+			expect: `// +patchKey=name
+test: [{
+	name:  "main"
+	image: "busybox"
+}]
+`,
+		},
+		{
+			src: `
 apply: containers: [{name: "main", image: "busybox"}]
 `,
 			script: `apply.containers[0].image`,

pkg/cue/process/handle.go

@@ -62,10 +62,12 @@ type templateContext struct {
 	// appName is the name of Application
 	appName string
 	// appRevision is the revision name of Application
-	appRevision string
-	configs     []map[string]string
-	base        model.Instance
-	auxiliaries []Auxiliary
+	appRevision    string
+	workflowName   string
+	publishVersion string
+	configs        []map[string]string
+	base           model.Instance
+	auxiliaries    []Auxiliary
 	// namespace is the namespace of Application which is used to set the namespace for Crossplane connection secret,
 	// ComponentDefinition/TratiDefinition OpenAPI v3 schema
 	namespace string
@@ -94,57 +96,41 @@ type RequiredSecrets struct {
 	Data        map[string]interface{}
 }
 
+// ContextData is the core data of process context
+type ContextData struct {
+	Namespace       string
+	AppName         string
+	CompName        string
+	AppRevisionName string
+	WorkflowName    string
+	PublishVersion  string
+
+	Ctx            context.Context
+	BaseHooks      []BaseHook
+	AuxiliaryHooks []AuxiliaryHook
+	Components     []common.ApplicationComponent
+}
+
 // NewContext create render templateContext
-func NewContext(namespace, name, appName, appRevision string) Context {
-	return &templateContext{
-		name:        name,
-		appName:     appName,
-		appRevision: appRevision,
+func NewContext(data ContextData) Context {
+	ctx := &templateContext{
+		namespace:      data.Namespace,
+		name:           data.CompName,
+		appName:        data.AppName,
+		appRevision:    data.AppRevisionName,
+		workflowName:   data.WorkflowName,
+		publishVersion: data.PublishVersion,
+
 		configs:     []map[string]string{},
 		auxiliaries: []Auxiliary{},
-		namespace:   namespace,
 		parameters:  map[string]interface{}{},
-	}
-}
 
-// NewProcessContextWithCtx create render templateContext with ctx
-func NewProcessContextWithCtx(ctx context.Context, namespace, name, appName, appRevision string) Context {
-	return &templateContext{
-		name:        name,
-		appName:     appName,
-		appRevision: appRevision,
-		configs:     []map[string]string{},
-		auxiliaries: []Auxiliary{},
-		namespace:   namespace,
-		parameters:  map[string]interface{}{},
-		ctx:         ctx,
-	}
-}
-
-// NewContextWithHooks create render templateContext with hooks for validation
-func NewContextWithHooks(namespace, name, appName, appRevision string, baseHooks []BaseHook, auxHooks []AuxiliaryHook) Context {
-	return &templateContext{
-		name:           name,
-		appName:        appName,
-		appRevision:    appRevision,
-		configs:        []map[string]string{},
-		auxiliaries:    []Auxiliary{},
-		namespace:      namespace,
-		parameters:     map[string]interface{}{},
-		baseHooks:      baseHooks,
-		auxiliaryHooks: auxHooks,
-	}
-}
-
-// NewPolicyContext create Application Scope templateContext for Policy
-func NewPolicyContext(namespace, name, appName, appRevision string, components []common.ApplicationComponent) Context {
-	return &templateContext{
-		name:        name,
-		appName:     appName,
-		appRevision: appRevision,
-		namespace:   namespace,
-		components:  components,
+		ctx:            data.Ctx,
+		baseHooks:      data.BaseHooks,
+		auxiliaryHooks: data.AuxiliaryHooks,
+		components:     data.Components,
 	}
+	return ctx
 }
 
 // SetParameters sets templateContext parameters
@@ -185,6 +171,8 @@ func (ctx *templateContext) BaseContextFile() string {
 	buff += fmt.Sprintf(model.ContextAppRevisionNum+": %d\n", revNum)
 	buff += fmt.Sprintf(model.ContextNamespace+": \"%s\"\n", ctx.namespace)
 	buff += fmt.Sprintf(model.ContextCompRevisionName+": \"%s\"\n", model.ComponentRevisionPlaceHolder)
+	buff += fmt.Sprintf(model.ContextWorkflowName+": \"%s\"\n", ctx.workflowName)
+	buff += fmt.Sprintf(model.ContextPublishVersion+": \"%s\"\n", ctx.publishVersion)
 
 	if ctx.base != nil {
 		buff += fmt.Sprintf(model.OutputFieldName+": %s\n", structMarshal(ctx.base.String()))

pkg/cue/process/handle_test.go

@@ -100,7 +100,14 @@ image: "myserver"
 		},
 	}
 
-	ctx := NewContext("myns", "mycomp", "myapp", "myapp-v1")
+	ctx := NewContext(ContextData{
+		AppName:         "myapp",
+		CompName:        "mycomp",
+		Namespace:       "myns",
+		AppRevisionName: "myapp-v1",
+		WorkflowName:    "myworkflow",
+		PublishVersion:  "mypublishversion",
+	})
 	ctx.SetBase(base)
 	ctx.AppendAuxiliaries(svcAux)
 	ctx.AppendAuxiliaries(svcAuxWithAbnormalName)
@@ -130,6 +137,14 @@ image: "myserver"
 	assert.Equal(t, nil, err)
 	assert.Equal(t, int64(1), myAppRevisionNum)
 
+	myWorkflowName, err := ctxInst.Lookup("context", model.ContextWorkflowName).String()
+	assert.Equal(t, nil, err)
+	assert.Equal(t, "myworkflow", myWorkflowName)
+
+	myPublishVersion, err := ctxInst.Lookup("context", model.ContextPublishVersion).String()
+	assert.Equal(t, nil, err)
+	assert.Equal(t, "mypublishversion", myPublishVersion)
+
 	inputJs, err := ctxInst.Lookup("context", model.OutputFieldName).MarshalJSON()
 	assert.Equal(t, nil, err)
 	assert.Equal(t, `{"image":"myserver"}`, string(inputJs))

pkg/oam/util/helper_test.go

@@ -591,10 +591,9 @@ func TestConvertWorkloadGVK2Def(t *testing.T) {
 		Version: "v1",
 	}, ref)
 
-	ref, err = util.ConvertWorkloadGVK2Definition(mapper, common.WorkloadGVK{APIVersion: "/apps/v1",
+	_, err = util.ConvertWorkloadGVK2Definition(mapper, common.WorkloadGVK{APIVersion: "/apps/v1",
 		Kind: "Deployment"})
 	assert.Error(t, err)
-
 }
 
 func TestGenTraitName(t *testing.T) {

pkg/velaql/view.go

@@ -30,6 +30,7 @@ import (
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
 	"github.com/oam-dev/kubevela/pkg/cue/model/value"
 	"github.com/oam-dev/kubevela/pkg/cue/packages"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	"github.com/oam-dev/kubevela/pkg/multicluster"
 	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 	oamutil "github.com/oam-dev/kubevela/pkg/oam/util"
@@ -82,7 +83,8 @@ func (handler *ViewHandler) QueryView(ctx context.Context, qv QueryView) (*value
 		Outputs:    queryKey.Outputs,
 	}
 
-	taskDiscover := tasks.NewViewTaskDiscover(handler.pd, handler.cli, handler.cfg, handler.dispatch, handler.delete, handler.namespace, 3)
+	pCtx := process.NewContext(process.ContextData{})
+	taskDiscover := tasks.NewViewTaskDiscover(handler.pd, handler.cli, handler.cfg, handler.dispatch, handler.delete, handler.namespace, 3, pCtx)
 	genTask, err := taskDiscover.GetTaskGenerator(ctx, handler.viewTask.Type)
 	if err != nil {
 		return nil, err

pkg/workflow/tasks/custom/task.go

@@ -31,6 +31,7 @@ import (
 	"github.com/oam-dev/kubevela/pkg/cue/model/sets"
 	"github.com/oam-dev/kubevela/pkg/cue/model/value"
 	"github.com/oam-dev/kubevela/pkg/cue/packages"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	monitorContext "github.com/oam-dev/kubevela/pkg/monitor/context"
 	wfContext "github.com/oam-dev/kubevela/pkg/workflow/context"
 	"github.com/oam-dev/kubevela/pkg/workflow/hooks"
@@ -197,7 +198,7 @@ func (t *TaskLoader) makeTaskGenerator(templ string) (wfTypes.TaskGenerator, err
 				paramFile = fmt.Sprintf(model.ParameterFieldName+": {%s}\n", ps)
 			}
 
-			taskv, err := t.makeValue(ctx, strings.Join([]string{templ, paramFile}, "\n"), exec.wfStatus.ID)
+			taskv, err := t.makeValue(ctx, strings.Join([]string{templ, paramFile}, "\n"), exec.wfStatus.ID, options.PCtx)
 			if err != nil {
 				exec.err(ctx, err, StatusReasonRendering)
 				return exec.status(), exec.operation(), nil
@@ -227,7 +228,7 @@ func (t *TaskLoader) makeTaskGenerator(templ string) (wfTypes.TaskGenerator, err
 	}, nil
 }
 
-func (t *TaskLoader) makeValue(ctx wfContext.Context, templ string, id string) (*value.Value, error) {
+func (t *TaskLoader) makeValue(ctx wfContext.Context, templ string, id string, pCtx process.Context) (*value.Value, error) {
 	var contextTempl string
 	meta, _ := ctx.GetVar(wfTypes.ContextKeyMetadata)
 	if meta != nil {
@@ -237,6 +238,7 @@ func (t *TaskLoader) makeValue(ctx wfContext.Context, templ string, id string) (
 		}
 		contextTempl = fmt.Sprintf("\ncontext: {%s}\ncontext: stepSessionID: \"%s\"", ms, id)
 	}
+	contextTempl += "\n" + pCtx.ExtendedContextFile()
 
 	return value.NewValue(templ+contextTempl, t.pd, contextTempl, value.ProcessScript, value.TagFieldOrder)
 }
@@ -415,7 +417,7 @@ func getLabel(v *value.Value, label string) string {
 }
 
 // NewTaskLoader create a tasks loader.
-func NewTaskLoader(lt LoadTaskTemplate, pkgDiscover *packages.PackageDiscover, handlers providers.Providers, logLevel int) *TaskLoader {
+func NewTaskLoader(lt LoadTaskTemplate, pkgDiscover *packages.PackageDiscover, handlers providers.Providers, logLevel int, pCtx process.Context) *TaskLoader {
 	return &TaskLoader{
 		loadTemplate: lt,
 		pd:           pkgDiscover,
@@ -423,6 +425,7 @@ func NewTaskLoader(lt LoadTaskTemplate, pkgDiscover *packages.PackageDiscover, h
 		runOptionsProcess: func(options *wfTypes.TaskRunOptions) {
 			options.PreStartHooks = append(options.PreStartHooks, hooks.Input)
 			options.PostStopHooks = append(options.PostStopHooks, hooks.Output)
+			options.PCtx = pCtx
 		},
 		logLevel: logLevel,
 	}

pkg/workflow/tasks/custom/task_test.go

@@ -34,6 +34,7 @@ import (
 	"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/cue/model/value"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	wfContext "github.com/oam-dev/kubevela/pkg/workflow/context"
 	"github.com/oam-dev/kubevela/pkg/workflow/hooks"
 	"github.com/oam-dev/kubevela/pkg/workflow/providers"
@@ -75,7 +76,13 @@ myIP: value: "1.1.1.1"
 		},
 	})
 
-	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0)
+	pCtx := process.NewContext(process.ContextData{
+		AppName:         "app",
+		CompName:        "app",
+		Namespace:       "default",
+		AppRevisionName: "app-v1",
+	})
+	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0, pCtx)
 
 	steps := []v1beta1.WorkflowStep{
 		{
@@ -178,7 +185,13 @@ close({
 			return errors.New("mock error")
 		},
 	})
-	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0)
+	pCtx := process.NewContext(process.ContextData{
+		AppName:         "app",
+		CompName:        "app",
+		Namespace:       "default",
+		AppRevisionName: "app-v1",
+	})
+	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0, pCtx)
 
 	steps := []v1beta1.WorkflowStep{
 		{
@@ -414,7 +427,13 @@ func TestPendingInputCheck(t *testing.T) {
 			ParameterKey: "score",
 		}},
 	}
-	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0)
+	pCtx := process.NewContext(process.ContextData{
+		AppName:         "myapp",
+		CompName:        "mycomp",
+		Namespace:       "default",
+		AppRevisionName: "myapp-v1",
+	})
+	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0, pCtx)
 	gen, err := tasksLoader.GetTaskGenerator(context.Background(), step.Type)
 	r.NoError(err)
 	run, err := gen(step, &types.GeneratorOptions{})
@@ -443,7 +462,13 @@ func TestPendingDependsOnCheck(t *testing.T) {
 		Type:      "ok",
 		DependsOn: []string{"depend"},
 	}
-	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0)
+	pCtx := process.NewContext(process.ContextData{
+		AppName:         "myapp",
+		CompName:        "mycomp",
+		Namespace:       "default",
+		AppRevisionName: "myapp-v1",
+	})
+	tasksLoader := NewTaskLoader(mockLoadTemplate, nil, discover, 0, pCtx)
 	gen, err := tasksLoader.GetTaskGenerator(context.Background(), step.Type)
 	r.NoError(err)
 	run, err := gen(step, &types.GeneratorOptions{})

pkg/workflow/tasks/discover.go

@@ -26,6 +26,7 @@ import (
 	"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/cue/packages"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 	"github.com/oam-dev/kubevela/pkg/velaql/providers/query"
 	wfContext "github.com/oam-dev/kubevela/pkg/workflow/context"
@@ -74,7 +75,7 @@ func suspend(step v1beta1.WorkflowStep, opt *types.GeneratorOptions) (types.Task
 }
 
 // NewTaskDiscover will create a client for load task generator.
-func NewTaskDiscover(providerHandlers providers.Providers, pd *packages.PackageDiscover, cli client.Client, dm discoverymapper.DiscoveryMapper) types.TaskDiscover {
+func NewTaskDiscover(providerHandlers providers.Providers, pd *packages.PackageDiscover, cli client.Client, dm discoverymapper.DiscoveryMapper, pCtx process.Context) types.TaskDiscover {
 	// install builtin provider
 	workspace.Install(providerHandlers)
 	email.Install(providerHandlers)
@@ -85,7 +86,7 @@ func NewTaskDiscover(providerHandlers providers.Providers, pd *packages.PackageD
 		builtins: map[string]types.TaskGenerator{
 			"suspend": suspend,
 		},
-		remoteTaskDiscover: custom.NewTaskLoader(templateLoader.LoadTaskTemplate, pd, providerHandlers, 0),
+		remoteTaskDiscover: custom.NewTaskLoader(templateLoader.LoadTaskTemplate, pd, providerHandlers, 0, pCtx),
 		templateLoader:     templateLoader,
 	}
 }
@@ -116,7 +117,7 @@ func (tr *suspendTaskRunner) Pending(ctx wfContext.Context) bool {
 }
 
 // NewViewTaskDiscover will create a client for load task generator.
-func NewViewTaskDiscover(pd *packages.PackageDiscover, cli client.Client, cfg *rest.Config, apply kube.Dispatcher, delete kube.Deleter, viewNs string, logLevel int) types.TaskDiscover {
+func NewViewTaskDiscover(pd *packages.PackageDiscover, cli client.Client, cfg *rest.Config, apply kube.Dispatcher, delete kube.Deleter, viewNs string, logLevel int, pCtx process.Context) types.TaskDiscover {
 	handlerProviders := providers.NewProviders()
 
 	// install builtin provider
@@ -128,7 +129,7 @@ func NewViewTaskDiscover(pd *packages.PackageDiscover, cli client.Client, cfg *r
 
 	templateLoader := template.NewViewTemplateLoader(cli, viewNs)
 	return &taskDiscover{
-		remoteTaskDiscover: custom.NewTaskLoader(templateLoader.LoadTaskTemplate, pd, handlerProviders, logLevel),
+		remoteTaskDiscover: custom.NewTaskLoader(templateLoader.LoadTaskTemplate, pd, handlerProviders, logLevel, pCtx),
 		templateLoader:     templateLoader,
 	}
 }

pkg/workflow/tasks/discover_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/pkg/errors"
 	"gotest.tools/assert"
 
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	"github.com/oam-dev/kubevela/pkg/workflow/tasks/custom"
 	"github.com/oam-dev/kubevela/pkg/workflow/types"
 )
@@ -46,11 +47,17 @@ func TestDiscover(t *testing.T) {
 			return "", makeErr(name)
 		}
 	}
+	pCtx := process.NewContext(process.ContextData{
+		AppName:         "myapp",
+		CompName:        "mycomp",
+		Namespace:       "default",
+		AppRevisionName: "myapp-v1",
+	})
 	discover := &taskDiscover{
 		builtins: map[string]types.TaskGenerator{
 			"suspend": suspend,
 		},
-		remoteTaskDiscover: custom.NewTaskLoader(loadTemplate, nil, nil, 0),
+		remoteTaskDiscover: custom.NewTaskLoader(loadTemplate, nil, nil, 0, pCtx),
 	}
 
 	_, err := discover.GetTaskGenerator(context.Background(), "suspend")

pkg/workflow/types/types.go

@@ -22,6 +22,7 @@ import (
 	"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/cue/model/value"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	monitorCtx "github.com/oam-dev/kubevela/pkg/monitor/context"
 	wfContext "github.com/oam-dev/kubevela/pkg/workflow/context"
 )
@@ -41,6 +42,7 @@ type TaskDiscover interface {
 // TaskRunOptions is the options for task run.
 type TaskRunOptions struct {
 	Data          *value.Value
+	PCtx          process.Context
 	PreStartHooks []TaskPreStartHook
 	PostStopHooks []TaskPostStopHook
 	GetTracer     func(id string, step v1beta1.WorkflowStep) monitorCtx.Context

references/appfile/addon.go

@@ -33,7 +33,7 @@ import (
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
 	"github.com/oam-dev/kubevela/apis/types"
 	"github.com/oam-dev/kubevela/pkg/appfile"
-	"github.com/oam-dev/kubevela/pkg/controller/utils"
+	"github.com/oam-dev/kubevela/pkg/cue/process"
 	util2 "github.com/oam-dev/kubevela/pkg/oam/util"
 	"github.com/oam-dev/kubevela/pkg/utils/common"
 	"github.com/oam-dev/kubevela/pkg/utils/util"
@@ -75,15 +75,13 @@ func ApplyTerraform(app *v1beta1.Application, k8sClient client.Client, ioStream
 		return nil, err
 	}
 
-	revisionName, _ := utils.GetAppNextRevision(app)
-
 	for i, wl := range appFile.Workloads {
 		switch wl.CapabilityCategory {
 		case types.TerraformCategory:
 			name := wl.Name
 			ioStream.Infof("\nApplying cloud resources %s\n", name)
 
-			tf, err := getTerraformJSONFiles(wl, appFile.Name, revisionName, namespace)
+			tf, err := getTerraformJSONFiles(wl, appfile.GenerateContextDataFromAppFile(appFile, wl.Name))
 			if err != nil {
 				return nil, fmt.Errorf("failed to get Terraform JSON files from workload %s: %w", name, err)
 			}
@@ -197,8 +195,8 @@ func generateSecretFromTerraformOutput(k8sClient client.Client, outputList []str
 }
 
 // getTerraformJSONFiles gets Terraform JSON files or modules from workload
-func getTerraformJSONFiles(wl *appfile.Workload, applicationName, revisionName string, namespace string) ([]byte, error) {
-	pCtx, err := appfile.PrepareProcessContext(wl, applicationName, revisionName, namespace)
+func getTerraformJSONFiles(wl *appfile.Workload, ctxData process.ContextData) ([]byte, error) {
+	pCtx, err := appfile.PrepareProcessContext(wl, ctxData)
 	if err != nil {
 		return nil, err
 	}

references/cli/registry_test.go

@@ -25,6 +25,7 @@ import (
 )
 
 func TestRegistry(t *testing.T) {
+	t.Skip("temporary pend this test")
 	testAddon := "dynamic-sa"
 	regName := "testReg"
 	localPath, err := filepath.Abs("../../e2e/plugin/testdata")

vela-templates/definitions/internal/component/webservice.cue

@@ -20,24 +20,50 @@ webservice: {
 				import "strconv"
 				ready: {
 					if context.output.status.readyReplicas == _|_ {
-						replica: "0"
+						readyReplicas: 0
 					}
+
 					if context.output.status.readyReplicas != _|_ {
-						replica:  strconv.FormatInt(context.output.status.readyReplicas, 10)
+						readyReplicas: context.output.status.readyReplicas
 					}
 				}
-				message: "Ready:" + ready.replica + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
+
+				message: "Ready:" + strconv.FormatInt(ready.readyReplicas, 10) + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
 				"""#
 			healthPolicy: #"""
 				ready: {
-					if context.output.status.readyReplicas == _|_ {
-						replica: 0
+					if context.output.status.updatedReplicas == _|_  {
+						updatedReplicas : 0
 					}
+
+					if context.output.status.updatedReplicas != _|_  {
+						updatedReplicas : context.output.status.updatedReplicas
+					}
+
+					if context.output.status.readyReplicas == _|_ {
+						readyReplicas: 0
+					}
+
 					if context.output.status.readyReplicas != _|_ {
-						replica:  context.output.status.readyReplicas
+						readyReplicas: context.output.status.readyReplicas
+					}
+
+					if context.output.status.replicas == _|_ {
+						replicas: 0
+					}
+					if context.output.status.replicas != _|_ {
+						replicas: context.output.status.replicas
+					}
+
+					if context.output.status.observedGeneration != _|_ {
+						observedGeneration: context.output.status.observedGeneration
+					}
+
+					if context.output.status.observedGeneration == _|_ {
+						observedGeneration: 0
 					}
 				}
-				isHealth: context.output.spec.replicas == ready.replica
+					isHealth: (context.output.spec.replicas == ready.readyReplicas) && (context.output.spec.replicas == ready.updatedReplicas) && (context.output.spec.replicas == ready.replicas) && (ready.observedGeneration == context.output.metadata.generation || ready.observedGeneration > context.output.metadata.generation)
 				"""#
 		}
 	}

vela-templates/definitions/internal/component/worker.cue

@@ -18,24 +18,50 @@ worker: {
 				import "strconv"
 				ready: {
 					if context.output.status.readyReplicas == _|_ {
-						replica: "0"
+						readyReplicas: 0
 					}
+
 					if context.output.status.readyReplicas != _|_ {
-						replica:  strconv.FormatInt(context.output.status.readyReplicas, 10)
+						readyReplicas: context.output.status.readyReplicas
 					}
 				}
-				message: "Ready:" + ready.replica + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
+
+				message: "Ready:" + strconv.FormatInt(ready.readyReplicas, 10) + "/" + strconv.FormatInt(context.output.spec.replicas, 10)
 				"""#
 			healthPolicy: #"""
 				ready: {
-					if context.output.status.readyReplicas == _|_ {
-						replica: 0
+					if context.output.status.updatedReplicas == _|_  {
+						updatedReplicas : 0
 					}
+
+					if context.output.status.updatedReplicas != _|_  {
+						updatedReplicas : context.output.status.updatedReplicas
+					}
+
+					if context.output.status.readyReplicas == _|_ {
+						readyReplicas: 0
+					}
+
 					if context.output.status.readyReplicas != _|_ {
-						replica:  context.output.status.readyReplicas
+						readyReplicas: context.output.status.readyReplicas
+					}
+
+					if context.output.status.replicas == _|_ {
+						replicas: 0
+					}
+					if context.output.status.replicas != _|_ {
+						replicas: context.output.status.replicas
+					}
+
+					if context.output.status.observedGeneration != _|_ {
+						observedGeneration: context.output.status.observedGeneration
+					}
+
+					if context.output.status.observedGeneration == _|_ {
+						observedGeneration: 0
 					}
 				}
-				isHealth: context.output.spec.replicas == ready.replica
+					isHealth: (context.output.spec.replicas == ready.readyReplicas) && (context.output.spec.replicas == ready.updatedReplicas) && (context.output.spec.replicas == ready.replicas) && (ready.observedGeneration == context.output.metadata.generation || ready.observedGeneration > context.output.metadata.generation)
 				"""#
 		}
 	}