GoSteps v1 [#13]

Merge pull request #13 from TanmoySG/v1

GoSteps Version 1

The v1 introduces breaking changes to how steps are defined, GoSteps types, context and execution.

Note: Existing v0.3.0-beta steps will no longer be supported by v1 go-steps and would have to be migrated to the new types. To use existing go-steps v0.3.* users of the library should not upgrade to v1.

Author: TanmoySG

README.md

@@ -2,81 +2,114 @@ package main
 
 import (
 	"fmt"
-	"time"
 
 	gosteps "github.com/TanmoySG/go-steps"
-	"github.com/TanmoySG/go-steps/example/funcs"
 )
 
-const (
-	stepMultiply = "Multiply"
-	stepDivide   = "Divide"
-)
+func main() {
 
-// reading/maintaining this is a bit tricky will add
-// a functional way to create this in the next version
-var steps = gosteps.Step{
-	Function: funcs.Add,
-	StepArgs: []interface{}{2},
-	NextStep: &gosteps.Step{
-		Function:         funcs.Sub,
-		StepArgs:         []interface{}{4},
-		NextStepResolver: nextStepResolver,
-		PossibleNextSteps: gosteps.PossibleNextSteps{
-			{
-				Name:     stepMultiply,
-				Function: funcs.Multiply,
-				StepArgs: []interface{}{-5},
-				NextStep: &gosteps.Step{
-					Function: funcs.Add,
-					StepArgs: []interface{}{100},
-					NextStep: &gosteps.Step{
-						Function: funcs.StepWillError3Times,
-						ErrorsToRetry: []error{
-							fmt.Errorf("error"),
-						},
-						NextStep: &gosteps.Step{
-							Function: funcs.StepWillErrorInfinitely,
-							ErrorsToRetry: []error{
-								fmt.Errorf("error"),
+	ctx := gosteps.NewGoStepsContext()
+
+	multipleDivide := gosteps.Step{
+		Name: "multipleDivide",
+		Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+			res := c.GetData("result").(int) * 2
+			return gosteps.MarkStateComplete().WithData(map[string]interface{}{
+				"result": res,
+			})
+		},
+		Branches: &gosteps.Branches{
+			Resolver: func(ctx gosteps.GoStepsCtx) gosteps.BranchName {
+				nx := ctx.GetData("result").(int)
+
+				if nx%2 == 0 {
+					return gosteps.BranchName("divide")
+				}
+				return gosteps.BranchName("multiple")
+			},
+			Branches: []gosteps.Branch{
+				{
+					BranchName: "divide",
+					Steps: gosteps.Steps{
+						{
+							Name: "step3.divide",
+							Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+								res := c.GetData("result").(int) / 2
+								return gosteps.MarkStateComplete().WithData(map[string]interface{}{
+									"result": res,
+								})
 							},
-							NextStep: &gosteps.Step{
-								Function: funcs.Multiply,
+						},
+					},
+				},
+				{
+					BranchName: "multiply",
+					Steps: gosteps.Steps{
+						{
+							Name: "step3.multiply",
+							Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+								res := c.GetData("result").(int) * 2
+								return gosteps.MarkStateComplete().WithData(map[string]interface{}{
+									"result": res,
+								})
 							},
-							StrictErrorCheck: false,
-							MaxAttempts:      5, // use gosteps.MaxMaxAttempts for Maximum Possible reattempts
 						},
-						MaxAttempts: 5,
-						RetrySleep:  1 * time.Second,
 					},
 				},
 			},
-			{
-				Name:     stepDivide,
-				Function: funcs.Divide,
-				StepArgs: []interface{}{-2},
+		},
+	}
+
+	steps := gosteps.Steps{
+		{
+			Name: "add",
+			Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+
+				res := c.GetData("n1").(int) + c.GetData("n2").(int)
+				return gosteps.MarkStateComplete().WithData(map[string]interface{}{
+					"result": res,
+				})
+			},
+			StepArgs: map[string]interface{}{
+				"n1": 5,
+				"n2": 4,
 			},
 		},
-	},
-}
+		{
+			Name: "subtract",
+			Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+				res := c.GetData("n1").(int) - c.GetData("result").(int)
+				return gosteps.MarkStateComplete().WithData(map[string]interface{}{
+					"result": res,
+				})
+			},
+			StepArgs: map[string]interface{}{
+				"n1": 5,
+			},
+		},
+		multipleDivide,
+		{
+			Name: "add",
+			Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+				res := c.GetData("result").(int) + 5
 
-func main() {
-	initArgs := []interface{}{5}
-	finalOutput, err := steps.Execute(initArgs...)
-	if err != nil {
-		fmt.Printf("error executing steps: %s, final output: [%s]\n", err, finalOutput)
+				return gosteps.MarkStateComplete().WithData(map[string]interface{}{
+					"result": res,
+				})
+			},
+		},
+		{
+			Name: "print",
+			Function: func(c gosteps.GoStepsCtx) gosteps.StepResult {
+				fmt.Println("result", c.GetData("result"))
+				return gosteps.MarkStateComplete()
+			},
+		},
 	}
 
-	fmt.Printf("Final Output: [%v]\n", finalOutput)
-}
-
-// step resolver
-func nextStepResolver(args ...any) string {
-	if args[0].(int) < 0 {
-		fmt.Printf("StepResolver [%v]: Arguments is Negative, going with Multiply\n", args)
-		return stepMultiply
+	root := gosteps.RootStep{
+		Steps: steps,
 	}
 
-	fmt.Printf("StepResolver [%v]: Arguments is Positive, going with Divide\n", args)
-	return stepDivide
+	root.Execute(ctx)
 }

example/dynamic-steps-example/diag.png

@@ -1,11 +1,3 @@
 module github.com/TanmoySG/go-steps
 
 go 1.18
-
-require github.com/stretchr/testify v1.8.4
-
-require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)

example/dynamic-steps-example/main.go

@@ -1,10 +0,0 @@
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

example/multistep-example/main.go

@@ -0,0 +1,73 @@
+package gosteps
+
+import (
+	"encoding/json"
+)
+
+type GoStepsCtxData map[string]interface{}
+
+type GoStepsCtx struct {
+	Data          GoStepsCtxData            `json:"data"`
+	StepsProgress map[StepName]StepProgress `json:"stepsProgress"`
+}
+
+type GoStepsContext interface {
+	getCtx() GoStepsCtx
+	SetData(key string, value interface{})
+	GetData(key string) interface{}
+	WithData(data map[string]interface{})
+}
+
+func NewGoStepsContext() GoStepsContext {
+	return GoStepsCtx{
+		Data:          GoStepsCtxData{},
+		StepsProgress: map[StepName]StepProgress{},
+	}
+}
+
+func (ctx GoStepsCtx) ToJson() (string, error) {
+	cBytes, err := json.Marshal(ctx)
+	if err != nil {
+		return "", err
+	}
+
+	return string(cBytes), nil
+}
+
+func (ctx GoStepsCtx) getCtx() GoStepsCtx {
+	return ctx
+}
+
+func (ctx GoStepsCtx) SetData(key string, value interface{}) {
+	ctx.Data[key] = value
+}
+
+func (ctx GoStepsCtx) GetData(key string) interface{} {
+	return ctx.Data[key]
+}
+
+func (ctx GoStepsCtx) WithData(data map[string]interface{}) {
+	for key, value := range data {
+		ctx.SetData(key, value)
+	}
+}
+
+func (ctx GoStepsCtx) SetProgress(step StepName, stepResult StepResult) GoStepsCtx {
+	ctx.StepsProgress[step] = StepProgress{
+		StepName:   step,
+		StepResult: stepResult,
+	}
+
+	return ctx
+}
+
+func (ctx GoStepsCtx) GetProgress(step StepName) StepProgress {
+	return ctx.StepsProgress[step]
+}
+
+// func (ctx GoStepsCtx) SetStepRetires(stepName StepName) GoStepsCtx {
+// 	progress := ctx.StepsProgress[stepName]
+// 	progress.StepRetries += 1
+// 	ctx.StepsProgress[stepName] = progress
+// 	return ctx
+// }

go-step-arch.jpg

@@ -0,0 +1,77 @@
+package gosteps
+
+type StepState string
+
+const (
+	StepStateComplete StepState = "StepStateComplete" // step completed successfully
+	StepStateFailed   StepState = "StepStateFailed"   // step failed to complete, without error
+	StepStateSkipped  StepState = "StepStateSkipped"  // step was skipped
+	StepStatePending  StepState = "StepStatePending"  // step is pending, should be retried
+	StepStateError    StepState = "StepStateError"    // step failed to complete, with error
+)
+
+type StepResult struct {
+	StepData    GoStepsCtxData `json:"stepData"`
+	StepState   StepState      `json:"stepState"`
+	StepMessage *string        `json:"stepMessage"`
+	StepError   *StepError     `json:"stepError,omitempty"`
+}
+
+type StepError struct {
+	StepErrorNameOrId string `json:"stepErrorNameOrId"`
+	StepErrorMessage  string `json:"stepErrorMessage"`
+}
+
+type StepProgress struct {
+	StepName   StepName   `json:"stepName"`
+	StepResult StepResult `json:"stepResult"`
+}
+
+func MarkState(state StepState) StepResult {
+	return StepResult{
+		StepState: state,
+	}
+}
+
+func MarkStateComplete() StepResult {
+	return MarkState(StepStateComplete)
+}
+
+func MarkStateFailed() StepResult {
+	return MarkState(StepStateFailed)
+}
+
+func MarkStateSkipped() StepResult {
+	return MarkState(StepStateSkipped)
+}
+
+func MarkStatePending() StepResult {
+	return MarkState(StepStatePending)
+}
+
+func MarkStateError() StepResult {
+	return MarkState(StepStateError)
+}
+
+func (sr StepResult) WithData(data GoStepsCtxData) StepResult {
+	sr.StepData = data
+	return sr
+}
+
+func (sr StepResult) WithMessage(message string) StepResult {
+	sr.StepMessage = &message
+	return sr
+}
+
+func (sr StepResult) WithWrappedError(e error) StepResult {
+	sr.StepError = &StepError{
+		StepErrorNameOrId: "error",
+		StepErrorMessage:  e.Error(),
+	}
+	return sr
+}
+
+func (sr StepResult) WithStepError(stepErr StepError) StepResult {
+	sr.StepError = &stepErr
+	return sr
+}