make CUE inner kube package as a standalone package && clean code (#1263)

pkg/dsl/definition/package_test.go

@@ -314,15 +314,13 @@ func TestPackage(t *testing.T) {
     }
 }
 `
-
-	pkg := newPackage("oss")
-	assert.NilError(t, pkg.addOpenAPI(openAPISchema))
-	pkg.mount()
+	mypd := &PackageDiscover{pkgKinds: make(map[string][]string)}
+	mypd.addKubeCUEPackagesFromCluster(openAPISchema)
 	bi := build.NewContext().NewInstance("", nil)
-	AddVelaInternalPackagesFor(bi)
+	mypd.ImportBuiltinPackagesFor(bi)
 	bi.AddFile("-", `
-import "oss"
-output: oss.#Bucket
+import "kube/test.io/v1"
+output: v1.#Bucket
 `)
 	var r cue.Runtime
 	inst, err := r.Build(bi)
@@ -430,13 +428,13 @@ func TestProcessFile(t *testing.T) {
 }
 
 func TestMount(t *testing.T) {
-	velaBuiltinPkgs = nil
+	mypd := &PackageDiscover{pkgKinds: make(map[string][]string)}
 	testPkg := newPackage("foo")
-	testPkg.mount()
-	assert.Equal(t, len(velaBuiltinPkgs), 1)
-	testPkg.mount()
-	assert.Equal(t, len(velaBuiltinPkgs), 1)
-	assert.Equal(t, velaBuiltinPkgs[0], testPkg.Instance)
+	mypd.mount(testPkg, []string{"abc"})
+	assert.Equal(t, len(mypd.velaBuiltinPackages), 1)
+	mypd.mount(testPkg, []string{"abc"})
+	assert.Equal(t, len(mypd.velaBuiltinPackages), 1)
+	assert.Equal(t, mypd.velaBuiltinPackages[0], testPkg.Instance)
 }
 
 func TestGetGVK(t *testing.T) {

pkg/dsl/definition/suit_test.go

@@ -39,6 +39,7 @@ var cfg *rest.Config
 var k8sClient client.Client
 var testEnv *envtest.Environment
 var scheme = runtime.NewScheme()
+var pd *PackageDiscover
 
 func TestDefinition(t *testing.T) {
 	RegisterFailHandler(Fail)
@@ -64,6 +65,8 @@ var _ = BeforeSuite(func(done Done) {
 	k8sClient, err = client.New(cfg, client.Options{Scheme: scheme})
 	Expect(err).ToNot(HaveOccurred())
 	Expect(k8sClient).ToNot(BeNil())
+	pd, err = NewPackageDiscover(cfg)
+	Expect(err).ToNot(HaveOccurred())
 
 	close(done)
 }, 60)

pkg/dsl/definition/template.go

@@ -39,15 +39,14 @@ const (
 
 // AbstractEngine defines Definition's Render interface
 type AbstractEngine interface {
-	Params(params interface{}) AbstractEngine
-	Complete(ctx process.Context, abstractTemplate string) error
+	Complete(ctx process.Context, abstractTemplate string, params interface{}) error
 	HealthCheck(ctx process.Context, cli client.Client, ns string, healthPolicyTemplate string) (bool, error)
 	Status(ctx process.Context, cli client.Client, ns string, customStatusTemplate string) (string, error)
 }
 
 type def struct {
-	name   string
-	params interface{}
+	name string
+	pd   *PackageDiscover
 }
 
 type workloadDef struct {
@@ -55,29 +54,23 @@ type workloadDef struct {
 }
 
 // NewWorkloadAbstractEngine create Workload Definition AbstractEngine
-func NewWorkloadAbstractEngine(name string) AbstractEngine {
+func NewWorkloadAbstractEngine(name string, pd *PackageDiscover) AbstractEngine {
 	return &workloadDef{
 		def: def{
-			name:   name,
-			params: nil,
+			name: name,
+			pd:   pd,
 		},
 	}
 }
 
-// Params set definition's params
-func (wd *workloadDef) Params(params interface{}) AbstractEngine {
-	wd.params = params
-	return wd
-}
-
 // Complete do workload definition's rendering
-func (wd *workloadDef) Complete(ctx process.Context, abstractTemplate string) error {
+func (wd *workloadDef) Complete(ctx process.Context, abstractTemplate string, params interface{}) error {
 	bi := build.NewContext().NewInstance("", nil)
 	if err := bi.AddFile("-", abstractTemplate); err != nil {
 		return errors.WithMessagef(err, "invalid cue template of workload %s", wd.name)
 	}
-	if wd.params != nil {
-		bt, err := json.Marshal(wd.params)
+	if params != nil {
+		bt, err := json.Marshal(params)
 		if err != nil {
 			return errors.WithMessagef(err, "marshal parameter of workload %s", wd.name)
 		}
@@ -89,40 +82,42 @@ func (wd *workloadDef) Complete(ctx process.Context, abstractTemplate string) er
 	if err := bi.AddFile("-", ctx.BaseContextFile()); err != nil {
 		return err
 	}
-	AddVelaInternalPackagesFor(bi)
+	wd.pd.ImportBuiltinPackagesFor(bi)
+	var r cue.Runtime
+	inst, err := r.Build(bi)
+	if err != nil {
+		return err
+	}
 
-	instances := cue.Build([]*build.Instance{bi})
-	for _, inst := range instances {
-		if err := inst.Value().Err(); err != nil {
-			return errors.WithMessagef(err, "invalid cue template of workload %s after merge parameter and context", wd.name)
-		}
-		output := inst.Lookup(OutputFieldName)
-		base, err := model.NewBase(output)
-		if err != nil {
-			return errors.WithMessagef(err, "invalid output of workload %s", wd.name)
-		}
-		ctx.SetBase(base)
+	if err := inst.Value().Err(); err != nil {
+		return errors.WithMessagef(err, "invalid cue template of workload %s after merge parameter and context", wd.name)
+	}
+	output := inst.Lookup(OutputFieldName)
+	base, err := model.NewBase(output)
+	if err != nil {
+		return errors.WithMessagef(err, "invalid output of workload %s", wd.name)
+	}
+	ctx.SetBase(base)
 
-		// we will support outputs for workload composition, and it will become trait in AppConfig.
-		outputs := inst.Lookup(OutputsFieldName)
-		if !outputs.Exists() {
+	// we will support outputs for workload composition, and it will become trait in AppConfig.
+	outputs := inst.Lookup(OutputsFieldName)
+	if !outputs.Exists() {
+		return nil
+	}
+	st, err := outputs.Struct()
+	if err != nil {
+		return errors.WithMessagef(err, "invalid outputs of workload %s", wd.name)
+	}
+	for i := 0; i < st.Len(); i++ {
+		fieldInfo := st.Field(i)
+		if fieldInfo.IsDefinition || fieldInfo.IsHidden || fieldInfo.IsOptional {
 			continue
 		}
-		st, err := outputs.Struct()
+		other, err := model.NewOther(fieldInfo.Value)
 		if err != nil {
-			return errors.WithMessagef(err, "invalid outputs of workload %s", wd.name)
-		}
-		for i := 0; i < st.Len(); i++ {
-			fieldInfo := st.Field(i)
-			if fieldInfo.IsDefinition || fieldInfo.IsHidden || fieldInfo.IsOptional {
-				continue
-			}
-			other, err := model.NewOther(fieldInfo.Value)
-			if err != nil {
-				return errors.WithMessagef(err, "invalid outputs(%s) of workload %s", fieldInfo.Name, wd.name)
-			}
-			ctx.AppendAuxiliaries(process.Auxiliary{Ins: other, Type: AuxiliaryWorkload, Name: fieldInfo.Name})
+			return errors.WithMessagef(err, "invalid outputs(%s) of workload %s", fieldInfo.Name, wd.name)
 		}
+		ctx.AppendAuxiliaries(process.Auxiliary{Ins: other, Type: AuxiliaryWorkload, Name: fieldInfo.Name})
 	}
 	return nil
 }
@@ -238,28 +233,23 @@ type traitDef struct {
 }
 
 // NewTraitAbstractEngine create Trait Definition AbstractEngine
-func NewTraitAbstractEngine(name string) AbstractEngine {
+func NewTraitAbstractEngine(name string, pd *PackageDiscover) AbstractEngine {
 	return &traitDef{
 		def: def{
 			name: name,
+			pd:   pd,
 		},
 	}
 }
 
-// Params set definition's params
-func (td *traitDef) Params(params interface{}) AbstractEngine {
-	td.params = params
-	return td
-}
-
 // Complete do trait definition's rendering
-func (td *traitDef) Complete(ctx process.Context, abstractTemplate string) error {
+func (td *traitDef) Complete(ctx process.Context, abstractTemplate string, params interface{}) error {
 	bi := build.NewContext().NewInstance("", nil)
 	if err := bi.AddFile("-", abstractTemplate); err != nil {
 		return errors.WithMessagef(err, "invalid template of trait %s", td.name)
 	}
-	if td.params != nil {
-		bt, err := json.Marshal(td.params)
+	if params != nil {
+		bt, err := json.Marshal(params)
 		if err != nil {
 			return errors.WithMessagef(err, "marshal parameter of trait %s", td.name)
 		}
@@ -271,7 +261,7 @@ func (td *traitDef) Complete(ctx process.Context, abstractTemplate string) error
 	if err := bi.AddFile("context", ctx.BaseContextFile()); err != nil {
 		return errors.WithMessagef(err, "invalid context of trait %s", td.name)
 	}
-	AddVelaInternalPackagesFor(bi)
+	td.pd.ImportBuiltinPackagesFor(bi)
 
 	instances := cue.Build([]*build.Instance{bi})
 	for _, inst := range instances {

pkg/dsl/definition/template_test.go

@@ -107,8 +107,8 @@ parameter: {
 
 	for _, v := range testCases {
 		ctx := process.NewContext("test", "myapp", "myapp-v1")
-		wt := NewWorkloadAbstractEngine("testworkload")
-		assert.NoError(t, wt.Params(v.params).Complete(ctx, v.workloadTemplate))
+		wt := NewWorkloadAbstractEngine("testworkload", &PackageDiscover{})
+		assert.NoError(t, wt.Complete(ctx, v.workloadTemplate, v.params))
 		base, assists := ctx.Output()
 		assert.Equal(t, len(v.expAssObjs), len(assists))
 		assert.NotNil(t, base)
@@ -432,6 +432,70 @@ parameter: {
 				"t3ingress": &unstructured.Unstructured{Object: map[string]interface{}{"apiVersion": "networking.k8s.io/v1beta1", "kind": "Ingress", "labels": map[string]interface{}{"config": "enemies-data"}, "metadata": map[string]interface{}{"name": "test"}, "spec": map[string]interface{}{"rules": []interface{}{map[string]interface{}{"host": "example.com", "http": map[string]interface{}{"paths": []interface{}{map[string]interface{}{"backend": map[string]interface{}{"serviceName": "test", "servicePort": int64(1080)}, "path": "ping"}}}}}}}},
 			},
 		},
+		"outputs trait with schema": {
+			traitTemplate: `
+#Service:{
+  apiVersion: string
+  kind: string
+}
+#Ingress:{
+  apiVersion: string
+  kind: string
+}
+outputs:{
+  service: #Service
+  ingress: #Ingress
+}
+outputs: service: {
+	apiVersion: "v1"
+    kind: "Service"
+}
+outputs: ingress: {
+	apiVersion: "extensions/v1beta1"
+    kind: "Ingress"
+}
+parameter: {
+	type: string
+	host: string
+}`,
+			params: map[string]interface{}{
+				"type": "ClusterIP",
+				"host": "example.com",
+			},
+			expWorkload: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "apps/v1",
+					"kind":       "Deployment",
+					"spec": map[string]interface{}{
+						"replicas": int64(2),
+						"selector": map[string]interface{}{
+							"matchLabels": map[string]interface{}{
+								"app.oam.dev/component": "test"}},
+						"template": map[string]interface{}{
+							"metadata": map[string]interface{}{
+								"labels": map[string]interface{}{"app.oam.dev/component": "test"},
+							},
+							"spec": map[string]interface{}{
+								"containers": []interface{}{map[string]interface{}{
+									"envFrom": []interface{}{map[string]interface{}{
+										"configMapRef": map[string]interface{}{"name": "testgame-config"},
+									}},
+									"image": "website:0.1",
+									"name":  "main",
+									"ports": []interface{}{map[string]interface{}{"containerPort": int64(443)}}}}}}}},
+			},
+			traitName: "t2",
+			expAssObjs: map[string]runtime.Object{
+				"AuxiliaryWorkloadgameconfig": &unstructured.Unstructured{
+					Object: map[string]interface{}{
+						"apiVersion": "v1",
+						"kind":       "ConfigMap",
+						"metadata":   map[string]interface{}{"name": "testgame-config"}, "data": map[string]interface{}{"enemies": "enemies-data", "lives": "lives-data"}},
+				},
+				"t2service": &unstructured.Unstructured{Object: map[string]interface{}{"apiVersion": "v1", "kind": "Service"}},
+				"t2ingress": &unstructured.Unstructured{Object: map[string]interface{}{"apiVersion": "extensions/v1beta1", "kind": "Ingress"}},
+			},
+		},
 	}
 
 	for cassinfo, v := range tds {
@@ -491,18 +555,18 @@ parameter: {
 
 `
 		ctx := process.NewContext("test", "myapp", "myapp-v1")
-		wt := NewWorkloadAbstractEngine("-")
-		if err := wt.Params(map[string]interface{}{
+		wt := NewWorkloadAbstractEngine("-", &PackageDiscover{})
+		if err := wt.Complete(ctx, baseTemplate, map[string]interface{}{
 			"replicas": 2,
 			"enemies":  "enemies-data",
 			"lives":    "lives-data",
 			"port":     443,
-		}).Complete(ctx, baseTemplate); err != nil {
+		}); err != nil {
 			t.Error(err)
 			return
 		}
-		td := NewTraitAbstractEngine(v.traitName)
-		assert.NoError(t, td.Params(v.params).Complete(ctx, v.traitTemplate))
+		td := NewTraitAbstractEngine(v.traitName, &PackageDiscover{})
+		assert.NoError(t, td.Complete(ctx, v.traitTemplate, v.params))
 		base, assists := ctx.Output()
 		assert.Equal(t, len(v.expAssObjs), len(assists), cassinfo)
 		assert.NotNil(t, base)

pkg/dsl/model/instance.go

 package model
 
 import (
+	"strings"
+
+	"github.com/pkg/errors"
+
+	"cuelang.org/go/cue/build"
+
 	"cuelang.org/go/cue"
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/format"
@@ -34,28 +40,31 @@ func (inst *instance) IsBase() bool {
 }
 
 func (inst *instance) Compile() ([]byte, error) {
+	bi := build.NewContext().NewInstance("", nil)
+	err := bi.AddFile("-", inst.v)
+	if err != nil {
+		return nil, err
+	}
 	var r cue.Runtime
-	cueInst, err := r.Compile("-", inst.v)
+	it, err := r.Build(bi)
 	if err != nil {
 		return nil, err
 	}
 	// compiled object should be final and concrete value
-	if err := cueInst.Value().Validate(cue.Concrete(true), cue.Final()); err != nil {
-		return nil, err
+	if err := it.Value().Validate(cue.Concrete(true), cue.Final()); err != nil {
+		return nil, it.Err
 	}
-	return cueInst.Value().MarshalJSON()
+	return it.Value().MarshalJSON()
 }
 
 // Unstructured convert cue values to unstructured.Unstructured
-// TODO(wonderflow): will it be better if we try to decode it to concrete object(such as K8s Deployment) by using runtime.Schema?ß
+// TODO(wonderflow): will it be better if we try to decode it to concrete object(such as K8s Deployment) by using runtime.Schema?
 func (inst *instance) Unstructured() (*unstructured.Unstructured, error) {
 	jsonv, err := inst.Compile()
 	if err != nil {
 		return nil, err
 	}
-
 	o := &unstructured.Unstructured{}
-
 	if err := o.UnmarshalJSON(jsonv); err != nil {
 		return nil, err
 	}
@@ -107,7 +116,13 @@ func openPrint(v cue.Value) (string, error) {
 	}
 
 	ret, err := format.Node(f)
-	return string(ret), err
+	if err != nil {
+		return "", err
+	}
+	if strings.Contains(string(ret), "_|_") {
+		return "", errors.New(string(ret))
+	}
+	return string(ret), nil
 }
 
 func listOpen(expr ast.Node) {

pkg/dsl/model/instance_test.go

@@ -122,5 +122,39 @@ output: {
 	assert.Error(t, err)
 	var expnil *unstructured.Unstructured
 	assert.Equal(t, expnil, data)
+}
 
+func TestError(t *testing.T) {
+	ins := &instance{
+		v: ``,
+	}
+	_, err := ins.Unstructured()
+	assert.Equal(t, err.Error(), "Object 'Kind' is missing in '{}'")
+	ins = &instance{
+		v: `
+apiVersion: "apps/v1"
+kind:       "Deployment"
+metadata: name: parameter.name
+`,
+	}
+	_, err = ins.Unstructured()
+	assert.Equal(t, err.Error(), `metadata.name: reference "parameter" not found`)
+	ins = &instance{
+		v: `
+apiVersion: "apps/v1"
+kind:       "Deployment"
+metadata: name: "abc"
+`,
+	}
+	obj, err := ins.Unstructured()
+	assert.Equal(t, err, nil)
+	assert.Equal(t, obj, &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": "apps/v1",
+			"kind":       "Deployment",
+			"metadata": map[string]interface{}{
+				"name": "abc",
+			},
+		},
+	})
 }

pkg/oam/util/template_test.go

@@ -4,10 +4,9 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"cuelang.org/go/cue"
 	"github.com/crossplane/crossplane-runtime/pkg/test"
+	"github.com/stretchr/testify/assert"
 	"k8s.io/apimachinery/pkg/runtime"
 	ktypes "k8s.io/apimachinery/pkg/types"
 

apis/types/args.go → pkg/utils/common/args.go

-package types
+package common
 
 import (
+	"fmt"
+
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/rest"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/config"
+
+	"github.com/oam-dev/kubevela/pkg/dsl/definition"
+	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 )
 
 // Args is args for controller-runtime client
@@ -12,6 +17,8 @@ type Args struct {
 	Config *rest.Config
 	Schema *runtime.Scheme
 	Client client.Client
+	dm     discoverymapper.DiscoveryMapper
+	pd     *definition.PackageDiscover
 }
 
 // SetConfig insert kubeconfig into Args
@@ -41,3 +48,39 @@ func (a *Args) GetClient() (client.Client, error) {
 	a.Client = newClient
 	return a.Client, nil
 }
+
+// GetDiscoveryMapper get discoveryMapper client if exist, create if not exist.
+func (a *Args) GetDiscoveryMapper() (discoverymapper.DiscoveryMapper, error) {
+	if a.Config == nil {
+		if err := a.SetConfig(); err != nil {
+			return nil, err
+		}
+	}
+	if a.dm != nil {
+		return a.dm, nil
+	}
+	dm, err := discoverymapper.New(a.Config)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create CRD discovery client %w", err)
+	}
+	a.dm = dm
+	return dm, nil
+}
+
+// GetPackageDiscover get PackageDiscover client if exist, create if not exist.
+func (a *Args) GetPackageDiscover() (*definition.PackageDiscover, error) {
+	if a.Config == nil {
+		if err := a.SetConfig(); err != nil {
+			return nil, err
+		}
+	}
+	if a.pd != nil {
+		return a.pd, nil
+	}
+	pd, err := definition.NewPackageDiscover(a.Config)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create CRD discovery for CUE package client %w", err)
+	}
+	a.pd = pd
+	return pd, nil
+}

pkg/utils/common/common.go

@@ -24,7 +24,6 @@ import (
 
 	core "github.com/oam-dev/kubevela/apis/core.oam.dev"
 	"github.com/oam-dev/kubevela/apis/standard.oam.dev/v1alpha1"
-	"github.com/oam-dev/kubevela/apis/types"
 	mycue "github.com/oam-dev/kubevela/pkg/cue"
 )
 
@@ -42,14 +41,14 @@ func init() {
 }
 
 // InitBaseRestConfig will return reset config for create controller runtime client
-func InitBaseRestConfig() (types.Args, error) {
+func InitBaseRestConfig() (Args, error) {
 	restConf, err := config.GetConfig()
 	if err != nil {
 		fmt.Println("get kubeConfig err", err)
 		os.Exit(1)
 	}
 
-	return types.Args{
+	return Args{
 		Config: restConf,
 		Schema: Scheme,
 	}, nil

pkg/webhook/core.oam.dev/register.go

@@ -3,6 +3,7 @@ package core_oam_dev
 import (
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 
+	controller "github.com/oam-dev/kubevela/pkg/controller/core.oam.dev"
 	"github.com/oam-dev/kubevela/pkg/webhook/core.oam.dev/v1alpha2/application"
 	"github.com/oam-dev/kubevela/pkg/webhook/core.oam.dev/v1alpha2/applicationconfiguration"
 	"github.com/oam-dev/kubevela/pkg/webhook/core.oam.dev/v1alpha2/applicationdeployment"
@@ -11,22 +12,13 @@ import (
 )
 
 // Register will be called in main and register all validation handlers
-func Register(mgr manager.Manager) error {
-	if err := application.RegisterValidatingHandler(mgr); err != nil {
-		return err
-	}
-	if err := applicationconfiguration.RegisterValidatingHandler(mgr); err != nil {
-		return err
-	}
-	if err := traitdefinition.RegisterValidatingHandler(mgr); err != nil {
-		return err
-	}
+func Register(mgr manager.Manager, args controller.Args) {
+	application.RegisterValidatingHandler(mgr, args)
+	applicationconfiguration.RegisterValidatingHandler(mgr, args)
+	traitdefinition.RegisterValidatingHandler(mgr, args)
 	applicationconfiguration.RegisterMutatingHandler(mgr)
 	applicationdeployment.RegisterMutatingHandler(mgr)
 	applicationdeployment.RegisterValidatingHandler(mgr)
-	if err := component.RegisterMutatingHandler(mgr); err != nil {
-		return err
-	}
+	component.RegisterMutatingHandler(mgr, args)
 	component.RegisterValidatingHandler(mgr)
-	return nil
 }

pkg/webhook/core.oam.dev/v1alpha2/application/validating_handler.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"net/http"
 
+	"github.com/oam-dev/kubevela/pkg/dsl/definition"
+
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
@@ -12,6 +14,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
+	controller "github.com/oam-dev/kubevela/pkg/controller/core.oam.dev"
 	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 	"github.com/oam-dev/kubevela/pkg/oam/util"
 )
@@ -21,6 +24,7 @@ var _ admission.Handler = &ValidatingHandler{}
 // ValidatingHandler handles application
 type ValidatingHandler struct {
 	dm     discoverymapper.DiscoveryMapper
+	pd     *definition.PackageDiscover
 	Client client.Client
 	// Decoder decodes objects
 	Decoder *admission.Decoder
@@ -75,13 +79,8 @@ func (h *ValidatingHandler) Handle(ctx context.Context, req admission.Request) a
 	return admission.ValidationResponse(true, "")
 }
 
-// RegisterValidatingHandler will regsiter application validate handler to the webhook
-func RegisterValidatingHandler(mgr manager.Manager) error {
-	mapper, err := discoverymapper.New(mgr.GetConfig())
-	if err != nil {
-		return err
-	}
+// RegisterValidatingHandler will register application validate handler to the webhook
+func RegisterValidatingHandler(mgr manager.Manager, args controller.Args) {
 	server := mgr.GetWebhookServer()
-	server.Register("/validating-core-oam-dev-v1alpha2-applications", &webhook.Admission{Handler: &ValidatingHandler{dm: mapper}})
-	return nil
+	server.Register("/validating-core-oam-dev-v1alpha2-applications", &webhook.Admission{Handler: &ValidatingHandler{dm: args.DiscoveryMapper, pd: args.PackageDiscover}})
 }

pkg/webhook/core.oam.dev/v1alpha2/application/validation.go

@@ -13,7 +13,7 @@ import (
 func (h *ValidatingHandler) ValidateCreate(ctx context.Context, app *v1alpha2.Application) field.ErrorList {
 	var componentErrs field.ErrorList
 	// try to generate an app file
-	appParser := appfile.NewApplicationParser(h.Client, h.dm)
+	appParser := appfile.NewApplicationParser(h.Client, h.dm, h.pd)
 	if _, err := appParser.GenerateAppFile(ctx, app.Name, app); err != nil {
 		componentErrs = append(componentErrs, field.Invalid(field.NewPath("spec"), app, err.Error()))
 	}

pkg/webhook/core.oam.dev/v1alpha2/applicationconfiguration/validating_handler.go

@@ -19,6 +19,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
+	controller "github.com/oam-dev/kubevela/pkg/controller/core.oam.dev"
 	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 	"github.com/oam-dev/kubevela/pkg/oam/util"
 )
@@ -313,14 +314,10 @@ func (h *ValidatingHandler) InjectDecoder(d *admission.Decoder) error {
 }
 
 // RegisterValidatingHandler will register application configuration validation to webhook
-func RegisterValidatingHandler(mgr manager.Manager) error {
+func RegisterValidatingHandler(mgr manager.Manager, args controller.Args) {
 	server := mgr.GetWebhookServer()
-	mapper, err := discoverymapper.New(mgr.GetConfig())
-	if err != nil {
-		return err
-	}
 	server.Register("/validating-core-oam-dev-v1alpha2-applicationconfigurations", &webhook.Admission{Handler: &ValidatingHandler{
-		Mapper: mapper,
+		Mapper: args.DiscoveryMapper,
 		Validators: []AppConfigValidator{
 			AppConfigValidateFunc(ValidateRevisionNameFn),
 			AppConfigValidateFunc(ValidateWorkloadNameForVersioningFn),
@@ -329,5 +326,4 @@ func RegisterValidatingHandler(mgr manager.Manager) error {
 			// TODO(wonderflow): Add more validation logic here.
 		},
 	}})
-	return nil
 }

pkg/webhook/core.oam.dev/v1alpha2/component/mutating_handler.go

@@ -22,8 +22,6 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
-
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/types"
@@ -35,8 +33,9 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
-
+	controller "github.com/oam-dev/kubevela/pkg/controller/core.oam.dev"
 	"github.com/oam-dev/kubevela/pkg/oam"
+	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 	"github.com/oam-dev/kubevela/pkg/oam/util"
 )
 
@@ -154,12 +153,7 @@ func (h *MutatingHandler) InjectDecoder(d *admission.Decoder) error {
 }
 
 // RegisterMutatingHandler will register component mutation handler to the webhook
-func RegisterMutatingHandler(mgr manager.Manager) error {
-	mapper, err := discoverymapper.New(mgr.GetConfig())
-	if err != nil {
-		return err
-	}
+func RegisterMutatingHandler(mgr manager.Manager, args controller.Args) {
 	server := mgr.GetWebhookServer()
-	server.Register("/mutating-core-oam-dev-v1alpha2-components", &webhook.Admission{Handler: &MutatingHandler{Mapper: mapper}})
-	return nil
+	server.Register("/mutating-core-oam-dev-v1alpha2-components", &webhook.Admission{Handler: &MutatingHandler{Mapper: args.DiscoveryMapper}})
 }

pkg/webhook/core.oam.dev/v1alpha2/traitdefinition/validating_handler.go

@@ -5,8 +5,7 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/oam-dev/kubevela/pkg/oam/util"
-
+	"github.com/pkg/errors"
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	"k8s.io/klog"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -15,10 +14,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
-	"github.com/pkg/errors"
-
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
+	controller "github.com/oam-dev/kubevela/pkg/controller/core.oam.dev"
 	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
+	"github.com/oam-dev/kubevela/pkg/oam/util"
 )
 
 const (
@@ -96,20 +95,15 @@ func (h *ValidatingHandler) InjectDecoder(d *admission.Decoder) error {
 }
 
 // RegisterValidatingHandler will register TraitDefinition validation to webhook
-func RegisterValidatingHandler(mgr manager.Manager) error {
+func RegisterValidatingHandler(mgr manager.Manager, args controller.Args) {
 	server := mgr.GetWebhookServer()
-	mapper, err := discoverymapper.New(mgr.GetConfig())
-	if err != nil {
-		return err
-	}
 	server.Register("/validating-core-oam-dev-v1alpha2-traitdefinitions", &webhook.Admission{Handler: &ValidatingHandler{
-		Mapper: mapper,
+		Mapper: args.DiscoveryMapper,
 		Validators: []TraitDefValidator{
 			TraitDefValidatorFn(ValidateDefinitionReference),
 			// add more validators here
 		},
 	}})
-	return nil
 }
 
 // ValidateDefinitionReference validates whether the trait definition is valid if

references/apiserver/api-server.go

@@ -5,11 +5,12 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/oam-dev/kubevela/pkg/utils/common"
+
 	"github.com/pkg/errors"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
-	"github.com/oam-dev/kubevela/apis/types"
 	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
 )
 
@@ -18,11 +19,11 @@ type APIServer struct {
 	server     *http.Server
 	KubeClient client.Client
 	dm         discoverymapper.DiscoveryMapper
-	c          types.Args
+	c          common.Args
 }
 
 // New will create APIServer
-func New(c types.Args, port, staticPath string) (*APIServer, error) {
+func New(c common.Args, port, staticPath string) (*APIServer, error) {
 	newClient, err := c.GetClient()
 	if err != nil {
 		return nil, err

references/apiserver/appHandlers.go

@@ -112,7 +112,7 @@ func (s *APIServer) CreateApplication(c *gin.Context) {
 		util.HandleError(c, util.StatusInternalServerError, err.Error())
 		return
 	}
-	err = o.BaseAppFileRun(buildResult, data, s.dm)
+	err = o.BaseAppFileRun(buildResult, data, s.c)
 	if err != nil {
 		util.HandleError(c, util.StatusInternalServerError, err.Error())
 		return

references/appfile/addon.go

@@ -18,7 +18,6 @@ import (
 	"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/oam/discoverymapper"
 	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"
@@ -32,11 +31,20 @@ const (
 )
 
 // ApplyTerraform deploys addon resources
-func ApplyTerraform(app *v1alpha2.Application, k8sClient client.Client, ioStream util.IOStreams, namespace string, dm discoverymapper.DiscoveryMapper) ([]v1alpha2.ApplicationComponent, error) {
+func ApplyTerraform(app *v1alpha2.Application, k8sClient client.Client, ioStream util.IOStreams, namespace string, args common.Args) ([]v1alpha2.ApplicationComponent, error) {
+	dm, err := args.GetDiscoveryMapper()
+	if err != nil {
+		return nil, err
+	}
+	pd, err := args.GetPackageDiscover()
+	if err != nil {
+		return nil, err
+	}
+
 	// TODO(zzxwill) Need to check whether authentication credentials of a specific cloud provider are exported as environment variables, like `ALICLOUD_ACCESS_KEY`
 	var nativeVelaComponents []v1alpha2.ApplicationComponent
 	// parse template
-	appParser := appfile.NewApplicationParser(k8sClient, dm)
+	appParser := appfile.NewApplicationParser(k8sClient, dm, pd)
 
 	ctx := util2.SetNamespaceInCtx(context.Background(), namespace)
 	appFile, err := appParser.GenerateAppFile(ctx, app.Name, app)

references/appfile/addon_test.go

@@ -10,7 +10,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
-	"github.com/oam-dev/kubevela/pkg/oam/discoverymapper"
+	"github.com/oam-dev/kubevela/pkg/utils/common"
 	"github.com/oam-dev/kubevela/pkg/utils/util"
 )
 
@@ -25,9 +25,8 @@ var _ = It("Test ApplyTerraform", func() {
 		}},
 	}
 	ioStream := util.IOStreams{In: os.Stdin, Out: os.Stdout, ErrOut: os.Stderr}
-	dm, _ := discoverymapper.New(cfg)
-	_, err := ApplyTerraform(app, k8sClient, ioStream, addonNamespace, dm)
-	Expect(err).ShouldNot(BeNil())
+	_, err := ApplyTerraform(app, k8sClient, ioStream, addonNamespace, common.Args{Config: cfg})
+	Expect(err).Should(BeNil())
 })
 
 var _ = Describe("Test generateSecretFromTerraformOutput", func() {

references/appfile/app.go

@@ -12,12 +12,13 @@ import (
 
 	"github.com/oam-dev/kubevela/apis/core.oam.dev/v1alpha2"
 	"github.com/oam-dev/kubevela/apis/types"
+	"github.com/oam-dev/kubevela/pkg/utils/common"
 	"github.com/oam-dev/kubevela/references/appfile/api"
 	"github.com/oam-dev/kubevela/references/appfile/template"
 )
 
 // NewEmptyApplication new empty application, only set tm
-func NewEmptyApplication(namespace string, c types.Args) (*api.Application, error) {
+func NewEmptyApplication(namespace string, c common.Args) (*api.Application, error) {
 	tm, err := template.Load(namespace, c)
 	if err != nil {
 		return nil, err
@@ -54,7 +55,7 @@ func Validate(app *api.Application) error {
 }
 
 // LoadApplication will load application from cluster.
-func LoadApplication(namespace, appName string, c types.Args) (*v1alpha2.Application, error) {
+func LoadApplication(namespace, appName string, c common.Args) (*v1alpha2.Application, error) {
 	newClient, err := c.GetClient()
 	if err != nil {
 		return nil, err