refactor the opt

controllers/workflowrun_controller.go

@@ -22,6 +22,8 @@ import (
 	"reflect"
 	"time"
 
+	"github.com/kubevela/workflow/pkg/opt"
+
 	"github.com/crossplane/crossplane-runtime/pkg/event"
 	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
@@ -127,11 +129,8 @@ func (r *WorkflowRunReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		return r.endWithNegativeCondition(logCtx, run, condition.ErrorCondition(v1alpha1.WorkflowRunConditionType, err))
 	}
 	isUpdate := instance.Status.Message != ""
+	runners, err := generator.GenerateRunners(logCtx, instance, opt.NewStepGeneratorOptions(r.Client, instance, opt.WithPackageDiscover(r.PackageDiscover)))
 
-	runners, err := generator.GenerateRunners(logCtx, instance, types.StepGeneratorOptions{
-		PackageDiscover: r.PackageDiscover,
-		Client:          r.Client,
-	})
 	if err != nil {
 		logCtx.Error(err, "[generate runners]")
 		r.Recorder.Event(run, event.Warning(v1alpha1.ReasonGenerate, errors.WithMessage(err, v1alpha1.MessageFailedGenerate)))

pkg/generator/generator.go

@@ -53,7 +53,6 @@ func GenerateRunners(ctx monitorContext.Context, instance *types.WorkflowInstanc
 		metrics.GenerateTaskRunnersDurationHistogram.WithLabelValues("workflowrun").Observe(v)
 	}))
 	defer subCtx.Commit("finish generate task runners")
-	options = initStepGeneratorOptions(ctx, instance, options)
 	taskDiscover := tasks.NewTaskDiscover(ctx, options)
 	var tasks []types.TaskRunner
 	for _, step := range instance.Steps {

pkg/generator/generator_test.go

@@ -21,6 +21,8 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/kubevela/workflow/pkg/opt"
+
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
@@ -29,7 +31,6 @@ import (
 	monitorContext "github.com/kubevela/pkg/monitor/context"
 
 	"github.com/kubevela/workflow/api/v1alpha1"
-	"github.com/kubevela/workflow/pkg/types"
 )
 
 var _ = Describe("Test workflow step runner generator", func() {
@@ -86,7 +87,7 @@ var _ = Describe("Test workflow step runner generator", func() {
 		instance, err := GenerateWorkflowInstance(ctx, k8sClient, wr)
 		Expect(err).Should(BeNil())
 		ctx := monitorContext.NewTraceContext(ctx, "test-wr")
-		runners, err := GenerateRunners(ctx, instance, types.StepGeneratorOptions{Client: k8sClient})
+		runners, err := GenerateRunners(ctx, instance, opt.NewStepGeneratorOptions(k8sClient, instance))
 		Expect(err).Should(BeNil())
 		Expect(len(runners)).Should(BeEquivalentTo(1))
 		Expect(runners[0].Name()).Should(BeEquivalentTo("step-1"))
@@ -128,7 +129,7 @@ var _ = Describe("Test workflow step runner generator", func() {
 		ctx := monitorContext.NewTraceContext(ctx, "test-wr-sub")
 		instance, err := GenerateWorkflowInstance(ctx, k8sClient, wr)
 		Expect(err).Should(BeNil())
-		runners, err := GenerateRunners(ctx, instance, types.StepGeneratorOptions{Client: k8sClient})
+		runners, err := GenerateRunners(ctx, instance, opt.NewStepGeneratorOptions(k8sClient, instance))
 		Expect(err).Should(BeNil())
 		Expect(len(runners)).Should(BeEquivalentTo(1))
 		Expect(runners[0].Name()).Should(BeEquivalentTo("step-1"))

pkg/opt/opt.go

@@ -0,0 +1,111 @@
+package opt
+
+import (
+	"github.com/kubevela/workflow/api/v1alpha1"
+	"github.com/kubevela/workflow/pkg/cue/packages"
+	"github.com/kubevela/workflow/pkg/cue/process"
+	"github.com/kubevela/workflow/pkg/providers"
+	"github.com/kubevela/workflow/pkg/providers/email"
+	"github.com/kubevela/workflow/pkg/providers/http"
+	"github.com/kubevela/workflow/pkg/providers/kube"
+	metrics2 "github.com/kubevela/workflow/pkg/providers/metrics"
+	"github.com/kubevela/workflow/pkg/providers/util"
+	"github.com/kubevela/workflow/pkg/providers/workspace"
+	"github.com/kubevela/workflow/pkg/tasks/template"
+	"github.com/kubevela/workflow/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/oam-dev/kubevela/pkg/config/provider"
+)
+
+type Option func(options *StepGeneratorOptions)
+
+// StepGeneratorOptions is the options for generate step.
+type StepGeneratorOptions struct {
+	Providers       types.Providers
+	PackageDiscover *packages.PackageDiscover
+	ProcessCtx      process.Context
+	TemplateLoader  template.Loader
+	Client          client.Client
+	StepConvertor   map[string]func(step v1alpha1.WorkflowStep) (v1alpha1.WorkflowStep, error)
+	LogLevel        int
+}
+
+func NewStepGeneratorOptions(client client.Client, instance *types.WorkflowInstance, opts ...Option) types.StepGeneratorOptions {
+	o := StepGeneratorOptions{
+		Client:         client,
+		Providers:      providers.NewProviders(),
+		TemplateLoader: template.NewWorkflowStepTemplateLoader(client),
+		LogLevel:       3,
+	}
+	for _, opt := range opts {
+		opt(&o)
+	}
+
+	installBuiltinProviders(instance, client, o.Providers, o.ProcessCtx)
+
+	return types.StepGeneratorOptions{
+		Providers:       o.Providers,
+		PackageDiscover: o.PackageDiscover,
+		ProcessCtx:      o.ProcessCtx,
+		TemplateLoader:  o.TemplateLoader,
+		Client:          o.Client,
+		StepConvertor:   o.StepConvertor,
+		LogLevel:        o.LogLevel,
+	}
+}
+
+func WithProviders(providers types.Providers) Option {
+	return func(o *StepGeneratorOptions) {
+		o.Providers = providers
+	}
+}
+
+func WithPackageDiscover(discover *packages.PackageDiscover) Option {
+	return func(o *StepGeneratorOptions) {
+		o.PackageDiscover = discover
+	}
+}
+
+func WithProcessCtx(ctx process.Context) Option {
+	return func(o *StepGeneratorOptions) {
+		o.ProcessCtx = ctx
+	}
+}
+
+func WithTemplateLoader(loader template.Loader) Option {
+	return func(o *StepGeneratorOptions) {
+		o.TemplateLoader = loader
+	}
+}
+
+func WithClient(c client.Client) Option {
+	return func(o *StepGeneratorOptions) {
+		o.Client = c
+	}
+}
+
+func WithStepConvertor(convertor map[string]func(step v1alpha1.WorkflowStep) (v1alpha1.WorkflowStep, error)) Option {
+	return func(o *StepGeneratorOptions) {
+		o.StepConvertor = convertor
+	}
+}
+
+func WithLogLevel(l int) Option {
+	return func(o *StepGeneratorOptions) {
+		o.LogLevel = l
+	}
+}
+
+func installBuiltinProviders(instance *types.WorkflowInstance, client client.Client, providerHandlers types.Providers, pCtx process.Context) {
+	workspace.Install(providerHandlers, pCtx)
+	email.Install(providerHandlers)
+	util.Install(providerHandlers, pCtx)
+	http.Install(providerHandlers, client, instance.Namespace)
+	provider.Install(providerHandlers, client, nil)
+	metrics2.Install(providerHandlers)
+	kube.Install(providerHandlers, client, map[string]string{
+		types.LabelWorkflowRunName:      instance.Name,
+		types.LabelWorkflowRunNamespace: instance.Namespace,
+	}, nil)
+}