From 23852b3d1033ffd9c5571ef1f11bba67f0815d2c Mon Sep 17 00:00:00 2001 From: FogDong Date: Fri, 21 Jan 2022 18:16:23 +0800 Subject: [PATCH] Feat: support vela show for workflow step definition Signed-off-by: FogDong --- pkg/cue/convert.go | 27 +++++++++--- pkg/cue/convert_test.go | 10 ++--- pkg/utils/common/common.go | 27 +++++++++--- pkg/utils/common/common_test.go | 4 +- references/cli/registry.go | 4 +- references/cli/show.go | 64 ++++++++++++++++++++++------ references/cli/show_test.go | 2 +- references/plugins/cluster.go | 49 ++++++++++++++++++--- references/plugins/cluster_test.go | 16 +++---- references/plugins/reference_test.go | 2 +- references/plugins/references.go | 25 ++++++++--- 11 files changed, 174 insertions(+), 56 deletions(-) diff --git a/pkg/cue/convert.go b/pkg/cue/convert.go index 0d9d8ae4a..5ffd9e4e2 100644 --- a/pkg/cue/convert.go +++ b/pkg/cue/convert.go @@ -22,17 +22,34 @@ import ( "strings" "cuelang.org/go/cue" + "cuelang.org/go/cue/build" "github.com/oam-dev/kubevela/apis/types" "github.com/oam-dev/kubevela/pkg/cue/model" + "github.com/oam-dev/kubevela/pkg/cue/packages" ) // GetParameters get parameter from cue template -func GetParameters(templateStr string) ([]types.Parameter, error) { - r := cue.Runtime{} - template, err := r.Compile("", templateStr+BaseTemplate) - if err != nil { - return nil, err +func GetParameters(templateStr string, pd *packages.PackageDiscover) ([]types.Parameter, error) { + var template *cue.Instance + var err error + if pd != nil { + bi := build.NewContext().NewInstance("", nil) + err := bi.AddFile("-", templateStr+BaseTemplate) + if err != nil { + return nil, err + } + + template, err = pd.ImportPackagesAndBuildInstance(bi) + if err != nil { + return nil, err + } + } else { + r := cue.Runtime{} + template, err = r.Compile("", templateStr+BaseTemplate) + if err != nil { + return nil, err + } } tempStruct, err := template.Value().Struct() if err != nil { diff --git a/pkg/cue/convert_test.go b/pkg/cue/convert_test.go index 2333fbd79..51e47588f 100644 --- a/pkg/cue/convert_test.go +++ b/pkg/cue/convert_test.go @@ -28,7 +28,7 @@ import ( func TestGetParameter(t *testing.T) { data, _ := os.ReadFile("testdata/workloads/metrics.cue") - params, err := GetParameters(string(data)) + params, err := GetParameters(string(data), nil) assert.NoError(t, err) assert.Equal(t, params, []types.Parameter{ {Name: "format", Required: false, Default: "prometheus", Usage: "format of the metrics, " + @@ -38,7 +38,7 @@ func TestGetParameter(t *testing.T) { {Name: "selector", Required: false, Usage: "the label selector for the pods, default is the workload labels", Type: cue.StructKind}, }) data, _ = os.ReadFile("testdata/workloads/deployment.cue") - params, err = GetParameters(string(data)) + params, err = GetParameters(string(data), nil) assert.NoError(t, err) assert.Equal(t, []types.Parameter{ {Name: "name", Required: true, Default: "", Type: cue.StringKind}, @@ -50,7 +50,7 @@ func TestGetParameter(t *testing.T) { params) data, _ = os.ReadFile("testdata/workloads/test-param.cue") - params, err = GetParameters(string(data)) + params, err = GetParameters(string(data), nil) assert.NoError(t, err) assert.Equal(t, []types.Parameter{ {Name: "name", Required: true, Default: "", Type: cue.StringKind}, @@ -61,13 +61,13 @@ func TestGetParameter(t *testing.T) { {Name: "fval", Default: 64.3, Type: cue.FloatKind}, {Name: "nval", Default: float64(0), Required: true, Type: cue.NumberKind}}, params) data, _ = os.ReadFile("testdata/workloads/empty.cue") - params, err = GetParameters(string(data)) + params, err = GetParameters(string(data), nil) assert.NoError(t, err) var exp []types.Parameter assert.Equal(t, exp, params) data, _ = os.ReadFile("testdata/workloads/webservice.cue") // test cue parameter with "// +ignore" annotation - params, err = GetParameters(string(data)) // Only test for func RetrieveComments + params, err = GetParameters(string(data), nil) // Only test for func RetrieveComments assert.NoError(t, err) var flag bool for _, para := range params { diff --git a/pkg/utils/common/common.go b/pkg/utils/common/common.go index f0c9e7dd8..b444efdea 100644 --- a/pkg/utils/common/common.go +++ b/pkg/utils/common/common.go @@ -30,6 +30,7 @@ import ( "cuelang.org/go/cue" "cuelang.org/go/cue/ast" + "cuelang.org/go/cue/build" "cuelang.org/go/cue/format" "cuelang.org/go/encoding/openapi" "github.com/AlecAivazis/survey/v2" @@ -62,6 +63,7 @@ import ( "github.com/oam-dev/kubevela/apis/types" velacue "github.com/oam-dev/kubevela/pkg/cue" "github.com/oam-dev/kubevela/pkg/cue/model" + "github.com/oam-dev/kubevela/pkg/cue/packages" "github.com/oam-dev/kubevela/pkg/oam" ) @@ -146,11 +148,26 @@ func HTTPGet(ctx context.Context, url string) ([]byte, error) { } // GetCUEParameterValue converts definitions to cue format -func GetCUEParameterValue(cueStr string) (cue.Value, error) { - r := cue.Runtime{} - template, err := r.Compile("", cueStr+velacue.BaseTemplate) - if err != nil { - return cue.Value{}, err +func GetCUEParameterValue(cueStr string, pd *packages.PackageDiscover) (cue.Value, error) { + var template *cue.Instance + var err error + if pd != nil { + bi := build.NewContext().NewInstance("", nil) + err := bi.AddFile("-", cueStr+velacue.BaseTemplate) + if err != nil { + return cue.Value{}, err + } + + template, err = pd.ImportPackagesAndBuildInstance(bi) + if err != nil { + return cue.Value{}, err + } + } else { + r := cue.Runtime{} + template, err = r.Compile("", cueStr+velacue.BaseTemplate) + if err != nil { + return cue.Value{}, err + } } tempStruct, err := template.Value().Struct() if err != nil { diff --git a/pkg/utils/common/common_test.go b/pkg/utils/common/common_test.go index aa592d697..15601f3fe 100644 --- a/pkg/utils/common/common_test.go +++ b/pkg/utils/common/common_test.go @@ -127,7 +127,7 @@ output: { for name, tc := range cases { t.Run(name, func(t *testing.T) { - _, err := GetCUEParameterValue(tc.cueStr) + _, err := GetCUEParameterValue(tc.cueStr, nil) if tc.want.err != nil { if diff := cmp.Diff(tc.want.err, err, test.EquateErrors()); diff != "" { t.Errorf("\n%s\nGenOpenAPIFromFile(...): -want error, +got error:\n%s", tc.reason, diff) @@ -162,7 +162,7 @@ name for name, tc := range cases { t.Run(name, func(t *testing.T) { - _, err := GetCUEParameterValue(tc.cueStr) + _, err := GetCUEParameterValue(tc.cueStr, nil) if diff := cmp.Diff(tc.want.errMsg, err.Error(), test.EquateConditions()); diff != "" { t.Errorf("\n%s\nGenOpenAPIFromFile(...): -want error, +got error:\n%s", tc.reason, diff) } diff --git a/references/cli/registry.go b/references/cli/registry.go index 750a7c941..f3d0f28ec 100644 --- a/references/cli/registry.go +++ b/references/cli/registry.go @@ -762,14 +762,14 @@ func ParseCapability(mapper discoverymapper.DiscoveryMapper, data []byte) (types } workloadDefinitionRef = ref.Name } - return plugins.HandleDefinition(cd.Name, workloadDefinitionRef, cd.Annotations, cd.Labels, cd.Spec.Extension, types.TypeComponentDefinition, nil, cd.Spec.Schematic) + return plugins.HandleDefinition(cd.Name, workloadDefinitionRef, cd.Annotations, cd.Labels, cd.Spec.Extension, types.TypeComponentDefinition, nil, cd.Spec.Schematic, nil) case "TraitDefinition": var td v1beta1.TraitDefinition err = yaml.Unmarshal(data, &td) if err != nil { return types.Capability{}, err } - return plugins.HandleDefinition(td.Name, td.Spec.Reference.Name, td.Annotations, td.Labels, td.Spec.Extension, types.TypeTrait, td.Spec.AppliesToWorkloads, td.Spec.Schematic) + return plugins.HandleDefinition(td.Name, td.Spec.Reference.Name, td.Annotations, td.Labels, td.Spec.Extension, types.TypeTrait, td.Spec.AppliesToWorkloads, td.Spec.Schematic, nil) case "ScopeDefinition": // TODO(wonderflow): support scope definition here. } diff --git a/references/cli/show.go b/references/cli/show.go index 8907a9e94..7e1f98e3d 100644 --- a/references/cli/show.go +++ b/references/cli/show.go @@ -32,6 +32,7 @@ import ( "github.com/spf13/cobra" "github.com/oam-dev/kubevela/apis/types" + "github.com/oam-dev/kubevela/pkg/cue/packages" "github.com/oam-dev/kubevela/pkg/utils/common" "github.com/oam-dev/kubevela/pkg/utils/system" cmdutil "github.com/oam-dev/kubevela/pkg/utils/util" @@ -62,8 +63,8 @@ var webSite bool func NewCapabilityShowCommand(c common.Args, ioStreams cmdutil.IOStreams) *cobra.Command { cmd := &cobra.Command{ Use: "show", - Short: "Show the reference doc for a component type or trait.", - Long: "Show the reference doc for component or trait types.", + Short: "Show the reference doc for a component, trait or workflow.", + Long: "Show the reference doc for component, trait or workflow types.", Example: `show webservice`, RunE: func(cmd *cobra.Command, args []string) error { if len(args) == 0 { @@ -126,7 +127,7 @@ func startReferenceDocsSite(ctx context.Context, ns string, c common.Args, ioStr } } if !capabilityIsValid { - return fmt.Errorf("%s is not a valid component type or trait", capabilityName) + return fmt.Errorf("%s is not a valid component, trait or workflow", capabilityName) } cli, err := c.GetClient() @@ -139,7 +140,15 @@ func startReferenceDocsSite(ctx context.Context, ns string, c common.Args, ioStr }, } - if err := ref.CreateMarkdown(ctx, capabilities, docsPath, plugins.ReferenceSourcePath); err != nil { + config, err := c.GetConfig() + if err != nil { + return err + } + pd, err := packages.NewPackageDiscover(config) + if err != nil { + return err + } + if err := ref.CreateMarkdown(ctx, capabilities, docsPath, plugins.ReferenceSourcePath, pd); err != nil { return err } @@ -171,6 +180,8 @@ func startReferenceDocsSite(ctx context.Context, ns string, c common.Args, ioStr case types.TypeScope: case types.TypeComponentDefinition: capabilityPath = plugins.ComponentDefinitionTypePath + case types.TypeWorkflowStep: + capabilityPath = plugins.WorkflowStepPath default: return fmt.Errorf("unsupported type: %v", capabilityType) } @@ -216,7 +227,7 @@ func launch(server *http.Server, errChan chan<- error) { func generateSideBar(capabilities []types.Capability, docsPath string) error { sideBar := filepath.Join(docsPath, SideBar) - components, traits := getComponentsAndTraits(capabilities) + components, traits, workflowsteps := getDefinitions(capabilities) f, err := os.Create(sideBar) if err != nil { return err @@ -237,6 +248,14 @@ func generateSideBar(capabilities []types.Capability, docsPath string) error { return err } } + if _, err := f.WriteString("- Workflow Steps\n"); err != nil { + return err + } + for _, t := range workflowsteps { + if _, err := f.WriteString(fmt.Sprintf(" - [%s](%s/%s.md)\n", t, plugins.WorkflowStepPath, t)); err != nil { + return err + } + } return nil } @@ -303,12 +322,12 @@ func generateREADME(capabilities []types.Capability, docsPath string) error { if err != nil { return err } - if _, err := f.WriteString("# KubeVela Reference Docs for Component Types and Traits\n" + - "Click the navigation bar on the left or the links below to look into the detailed referennce of a Workload type or a Trait.\n"); err != nil { + if _, err := f.WriteString("# KubeVela Reference Docs for Component Types, Traits and WorkflowSteps\n" + + "Click the navigation bar on the left or the links below to look into the detailed reference of a Workload type, Trait or Workflow Step.\n"); err != nil { return err } - workloads, traits := getComponentsAndTraits(capabilities) + workloads, traits, workflowsteps := getDefinitions(capabilities) if _, err := f.WriteString("## Component Types\n"); err != nil { return err @@ -328,28 +347,47 @@ func generateREADME(capabilities []types.Capability, docsPath string) error { return err } } + + if _, err := f.WriteString("## Workflow Steps\n"); err != nil { + return err + } + for _, t := range workflowsteps { + if _, err := f.WriteString(fmt.Sprintf(" - [%s](%s/%s.md)\n", t, plugins.WorkflowStepPath, t)); err != nil { + return err + } + } return nil } -func getComponentsAndTraits(capabilities []types.Capability) ([]string, []string) { - var components, traits []string +func getDefinitions(capabilities []types.Capability) ([]string, []string, []string) { + var components, traits, workflowSteps []string for _, c := range capabilities { switch c.Type { case types.TypeComponentDefinition: components = append(components, c.Name) case types.TypeTrait: traits = append(traits, c.Name) + case types.TypeWorkflowStep: + workflowSteps = append(workflowSteps, c.Name) case types.TypeScope: case types.TypeWorkload: default: } } - return components, traits + return components, traits, workflowSteps } // ShowReferenceConsole will show capability reference in console func ShowReferenceConsole(ctx context.Context, c common.Args, ioStreams cmdutil.IOStreams, capabilityName string, ns string) error { - capability, err := plugins.GetCapabilityByName(ctx, c, capabilityName, ns) + config, err := c.GetConfig() + if err != nil { + return err + } + pd, err := packages.NewPackageDiscover(config) + if err != nil { + return err + } + capability, err := plugins.GetCapabilityByName(ctx, c, capabilityName, ns, pd) if err != nil { return err } @@ -377,7 +415,7 @@ func ShowReferenceConsole(ctx context.Context, c common.Args, ioStreams cmdutil. return err } case types.CUECategory: - propertyConsole, err = ref.GenerateCUETemplateProperties(capability) + propertyConsole, err = ref.GenerateCUETemplateProperties(capability, pd) if err != nil { return err } diff --git a/references/cli/show_test.go b/references/cli/show_test.go index 4d5405c35..87611d6c0 100644 --- a/references/cli/show_test.go +++ b/references/cli/show_test.go @@ -190,7 +190,7 @@ func TestGetWorkloadAndTraits(t *testing.T) { } for name, tc := range cases { t.Run(name, func(t *testing.T) { - gotWorkloads, gotTraits := getComponentsAndTraits(tc.capabilities) + gotWorkloads, gotTraits, _ := getDefinitions(tc.capabilities) assert.Equal(t, tc.want, want{workloads: gotWorkloads, traits: gotTraits}) }) } diff --git a/references/plugins/cluster.go b/references/plugins/cluster.go index 00b2c6b6f..78ee6f556 100644 --- a/references/plugins/cluster.go +++ b/references/plugins/cluster.go @@ -35,6 +35,7 @@ import ( "github.com/oam-dev/kubevela/apis/types" "github.com/oam-dev/kubevela/pkg/appfile" "github.com/oam-dev/kubevela/pkg/cue" + "github.com/oam-dev/kubevela/pkg/cue/packages" "github.com/oam-dev/kubevela/pkg/oam/discoverymapper" "github.com/oam-dev/kubevela/pkg/oam/util" "github.com/oam-dev/kubevela/pkg/utils/common" @@ -212,9 +213,9 @@ func validateCapabilities(tmp *types.Capability, dm discoverymapper.DiscoveryMap // HandleDefinition will handle definition to capability func HandleDefinition(name, crdName string, annotation, labels map[string]string, extension *runtime.RawExtension, tp types.CapType, - applyTo []string, schematic *commontypes.Schematic) (types.Capability, error) { + applyTo []string, schematic *commontypes.Schematic, pd *packages.PackageDiscover) (types.Capability, error) { var tmp types.Capability - tmp, err := HandleTemplate(extension, schematic, name) + tmp, err := HandleTemplate(extension, schematic, name, pd) if err != nil { return types.Capability{}, err } @@ -242,7 +243,7 @@ func GetDescription(annotation map[string]string) string { } // HandleTemplate will handle definition template to capability -func HandleTemplate(in *runtime.RawExtension, schematic *commontypes.Schematic, name string) (types.Capability, error) { +func HandleTemplate(in *runtime.RawExtension, schematic *commontypes.Schematic, name string, pd *packages.PackageDiscover) (types.Capability, error) { tmp, err := appfile.ConvertTemplateJSON2Object(name, in, schematic) if err != nil { return types.Capability{}, err @@ -282,7 +283,7 @@ func HandleTemplate(in *runtime.RawExtension, schematic *commontypes.Schematic, } return types.Capability{}, errors.New("template not exist in definition") } - tmp.Parameters, err = cue.GetParameters(tmp.CueTemplate) + tmp.Parameters, err = cue.GetParameters(tmp.CueTemplate, pd) if err != nil { return types.Capability{}, err } @@ -291,7 +292,7 @@ func HandleTemplate(in *runtime.RawExtension, schematic *commontypes.Schematic, } // GetCapabilityByName gets capability by definition name -func GetCapabilityByName(ctx context.Context, c common.Args, capabilityName string, ns string) (*types.Capability, error) { +func GetCapabilityByName(ctx context.Context, c common.Args, capabilityName string, ns string, pd *packages.PackageDiscover) (*types.Capability, error) { var ( foundCapability bool capability *types.Capability @@ -357,6 +358,25 @@ func GetCapabilityByName(ctx context.Context, c common.Args, capabilityName stri } return capability, nil } + + var wfStepDef v1beta1.WorkflowStepDefinition + err = newClient.Get(ctx, client.ObjectKey{Namespace: ns, Name: capabilityName}, &wfStepDef) + if err == nil { + foundCapability = true + } else if kerrors.IsNotFound(err) { + err = newClient.Get(ctx, client.ObjectKey{Namespace: types.DefaultKubeVelaNS, Name: capabilityName}, &wfStepDef) + if err == nil { + foundCapability = true + } + } + if foundCapability { + capability, err = GetCapabilityByWorkflowStepDefinitionObject(wfStepDef, pd) + if err != nil { + return nil, err + } + return capability, nil + } + if ns == types.DefaultKubeVelaNS { return nil, fmt.Errorf("could not find %s in namespace %s", capabilityName, ns) } @@ -366,7 +386,7 @@ func GetCapabilityByName(ctx context.Context, c common.Args, capabilityName stri // GetCapabilityByComponentDefinitionObject gets capability by ComponentDefinition object func GetCapabilityByComponentDefinitionObject(componentDef v1beta1.ComponentDefinition, referenceName string) (*types.Capability, error) { capability, err := HandleDefinition(componentDef.Name, referenceName, componentDef.Annotations, componentDef.Labels, - componentDef.Spec.Extension, types.TypeComponentDefinition, nil, componentDef.Spec.Schematic) + componentDef.Spec.Extension, types.TypeComponentDefinition, nil, componentDef.Spec.Schematic, nil) if err != nil { return nil, errors.Wrap(err, "failed to handle ComponentDefinition") } @@ -381,10 +401,25 @@ func GetCapabilityByTraitDefinitionObject(traitDef v1beta1.TraitDefinition) (*ty err error ) capability, err = HandleDefinition(traitDef.Name, traitDef.Spec.Reference.Name, traitDef.Annotations, traitDef.Labels, - traitDef.Spec.Extension, types.TypeTrait, nil, traitDef.Spec.Schematic) + traitDef.Spec.Extension, types.TypeTrait, nil, traitDef.Spec.Schematic, nil) if err != nil { return nil, errors.Wrap(err, "failed to handle TraitDefinition") } capability.Namespace = traitDef.Namespace return &capability, nil } + +// GetCapabilityByWorkflowStepDefinitionObject gets capability by WorkflowStepDefinition object +func GetCapabilityByWorkflowStepDefinitionObject(wfStepDef v1beta1.WorkflowStepDefinition, pd *packages.PackageDiscover) (*types.Capability, error) { + var ( + capability types.Capability + err error + ) + capability, err = HandleDefinition(wfStepDef.Name, wfStepDef.Spec.Reference.Name, wfStepDef.Annotations, wfStepDef.Labels, + nil, types.TypeWorkflowStep, nil, wfStepDef.Spec.Schematic, pd) + if err != nil { + return nil, errors.Wrap(err, "failed to handle WorkflowStepDefinition") + } + capability.Namespace = wfStepDef.Namespace + return &capability, nil +} diff --git a/references/plugins/cluster_test.go b/references/plugins/cluster_test.go index 42ffcf14b..8f968f17b 100644 --- a/references/plugins/cluster_test.go +++ b/references/plugins/cluster_test.go @@ -227,15 +227,15 @@ var _ = Describe("test GetCapabilityByName", func() { It("get capability", func() { Context("ComponentDefinition is in the current namespace", func() { - _, err := GetCapabilityByName(ctx, c, component1, ns) + _, err := GetCapabilityByName(ctx, c, component1, ns, nil) Expect(err).Should(BeNil()) }) Context("ComponentDefinition is in the default namespace", func() { - _, err := GetCapabilityByName(ctx, c, component2, ns) + _, err := GetCapabilityByName(ctx, c, component2, ns, nil) Expect(err).Should(BeNil()) }) Context("ComponentDefinition is in the default namespace", func() { - cap, err := GetCapabilityByName(ctx, c, component3, ns) + cap, err := GetCapabilityByName(ctx, c, component3, ns, nil) Expect(err).Should(BeNil()) jsontmp, err := json.Marshal(cap.KubeParameter) Expect(err).Should(BeNil()) @@ -245,20 +245,20 @@ var _ = Describe("test GetCapabilityByName", func() { Expect(string(jsontmp)).Should(ContainSubstring("the specific container port num which can accept external request.")) }) Context("ComponentDefinition's workload type is AutoDetectWorkloadDefinition", func() { - _, err := GetCapabilityByName(ctx, c, component4, ns) + _, err := GetCapabilityByName(ctx, c, component4, ns, nil) Expect(err).Should(BeNil()) }) Context("TraitDefinition is in the current namespace", func() { - _, err := GetCapabilityByName(ctx, c, trait1, ns) + _, err := GetCapabilityByName(ctx, c, trait1, ns, nil) Expect(err).Should(BeNil()) }) Context("TraitDefinition is in the default namespace", func() { - _, err := GetCapabilityByName(ctx, c, trait2, ns) + _, err := GetCapabilityByName(ctx, c, trait2, ns, nil) Expect(err).Should(BeNil()) }) Context("TraitDefinition is in the default namespace", func() { - cap, err := GetCapabilityByName(ctx, c, trait3, ns) + cap, err := GetCapabilityByName(ctx, c, trait3, ns, nil) Expect(err).Should(BeNil()) jsontmp, err := json.Marshal(cap.KubeParameter) Expect(err).Should(BeNil()) @@ -267,7 +267,7 @@ var _ = Describe("test GetCapabilityByName", func() { }) Context("capability cloud not be found", func() { - _, err := GetCapabilityByName(ctx, c, "a-component-definition-not-existed", ns) + _, err := GetCapabilityByName(ctx, c, "a-component-definition-not-existed", ns, nil) Expect(err).Should(HaveOccurred()) }) }) diff --git a/references/plugins/reference_test.go b/references/plugins/reference_test.go index 559a72003..1c2d7a673 100644 --- a/references/plugins/reference_test.go +++ b/references/plugins/reference_test.go @@ -149,7 +149,7 @@ variable "acl" { for name, tc := range cases { t.Run(name, func(t *testing.T) { - got := tc.ref.CreateMarkdown(ctx, tc.capabilities, RefTestDir, ReferenceSourcePath) + got := tc.ref.CreateMarkdown(ctx, tc.capabilities, RefTestDir, ReferenceSourcePath, nil) if diff := cmp.Diff(tc.want, got, test.EquateErrors()); diff != "" { t.Errorf("\n%s\nCreateMakrdown(...): -want error, +got error:\n%s", tc.reason, diff) } diff --git a/references/plugins/references.go b/references/plugins/references.go index 8b141aaa1..0e419f008 100644 --- a/references/plugins/references.go +++ b/references/plugins/references.go @@ -36,6 +36,7 @@ import ( "github.com/oam-dev/kubevela/pkg/controller/utils" velacue "github.com/oam-dev/kubevela/pkg/cue" "github.com/oam-dev/kubevela/pkg/cue/model" + "github.com/oam-dev/kubevela/pkg/cue/packages" "github.com/oam-dev/kubevela/pkg/utils/common" "github.com/oam-dev/kubevela/pkg/utils/terraform" ) @@ -55,6 +56,8 @@ const ( WorkloadTypePath = "workload-types" // TraitPath is the URL path for trait typed capability TraitPath = "traits" + // WorkflowStepPath is the URL path for workflow step typed capability + WorkflowStepPath = "workflowsteps" ) // Int64Type is int64 type @@ -556,6 +559,14 @@ func (ref *MarkdownReference) GenerateReferenceDocs(ctx context.Context, c commo caps []types.Capability err error ) + config, err := c.GetConfig() + if err != nil { + return err + } + pd, err := packages.NewPackageDiscover(config) + if err != nil { + return err + } if ref.DefinitionName == "" { caps, err = LoadAllInstalledCapability("default", c) @@ -563,18 +574,18 @@ func (ref *MarkdownReference) GenerateReferenceDocs(ctx context.Context, c commo return fmt.Errorf("failed to get all capabilityes: %w", err) } } else { - cap, err := GetCapabilityByName(ctx, c, ref.DefinitionName, namespace) + cap, err := GetCapabilityByName(ctx, c, ref.DefinitionName, namespace, pd) if err != nil { return fmt.Errorf("failed to get capability capability %s: %w", ref.DefinitionName, err) } caps = []types.Capability{*cap} } - return ref.CreateMarkdown(ctx, caps, baseRefPath, ReferenceSourcePath) + return ref.CreateMarkdown(ctx, caps, baseRefPath, ReferenceSourcePath, pd) } // CreateMarkdown creates markdown based on capabilities -func (ref *MarkdownReference) CreateMarkdown(ctx context.Context, caps []types.Capability, baseRefPath, referenceSourcePath string) error { +func (ref *MarkdownReference) CreateMarkdown(ctx context.Context, caps []types.Capability, baseRefPath, referenceSourcePath string, pd *packages.PackageDiscover) error { setDisplayFormat("markdown") for i, c := range caps { var ( @@ -610,7 +621,7 @@ func (ref *MarkdownReference) CreateMarkdown(ctx context.Context, caps []types.C capNameInTitle := ref.makeReadableTitle(capName) switch c.Category { case types.CUECategory: - cueValue, err := common.GetCUEParameterValue(c.CueTemplate) + cueValue, err := common.GetCUEParameterValue(c.CueTemplate, pd) if err != nil { return fmt.Errorf("failed to retrieve `parameters` value from %s with err: %w", c.Name, err) } @@ -821,7 +832,7 @@ func (ref *ParseReference) parseParameters(paraValue cue.Value, paramKey string, param.Type = val.IncompleteKind() switch val.IncompleteKind() { case cue.StructKind: - if subField, _ := val.Struct(); subField.Len() == 0 { // err cannot be not nil,so ignore it + if subField, err := val.Struct(); err == nil && subField.Len() == 0 { // err cannot be not nil,so ignore it if mapValue, ok := val.Elem(); ok { // In the future we could recursive call to surpport complex map-value(struct or list) param.PrintableType = fmt.Sprintf("map[string]%s", mapValue.IncompleteKind().String()) @@ -932,11 +943,11 @@ func (ref *MarkdownReference) generateConflictWithAndMore(capabilityName string, } // GenerateCUETemplateProperties get all properties of a capability -func (ref *ConsoleReference) GenerateCUETemplateProperties(capability *types.Capability) ([]ConsoleReference, error) { +func (ref *ConsoleReference) GenerateCUETemplateProperties(capability *types.Capability, pd *packages.PackageDiscover) ([]ConsoleReference, error) { setDisplayFormat("console") capName := capability.Name - cueValue, err := common.GetCUEParameterValue(capability.CueTemplate) + cueValue, err := common.GetCUEParameterValue(capability.CueTemplate, pd) if err != nil { return nil, fmt.Errorf("failed to retrieve `parameters` value from %s with err: %w", capName, err) }