docs(sdk-go): Update examples in Go

docs/docs/05-developer-guide/08-wfspec-development/06-exception-handling.md

@@ -218,10 +218,10 @@ wf.handleError(
 ```go
 threadsResult := wf.WaitForThreads(...)
 
-errorName := "TIMEOUT"
+exnToHandle := littlehorse.Timeout
 wf.HandleError(
     &threadsResult,
-    &errorName, // handle only TIMEOUT error. Leave nil to catch all ERROR.
+    &exnToHandle, // handle only TIMEOUT error. Leave nil to catch all ERROR.
     func(handler *littlehorse.WorkflowThread) {
         handler.Execute("some-task-in-my-exn-handler")
     },

sdk-go/examples/basic/README.md

@@ -14,7 +14,7 @@ The file [workflow.go](./workflow.go) has two functions defined:
 Before we can create the `WfSpec`, we need to register the `TaskDef`. The easiest way to do that is to run the task worker:
 
 ```
-go run ./basic/worker
+go run ./examples/basic/worker
 ```
 
 Leave that process running.
@@ -24,21 +24,21 @@ Leave that process running.
 Next, in another terminal, run:
 
 ```
-go run ./basic/deploy
+go run ./examples/basic/deploy
 ```
 
 That will create the `WfSpec`. You can verify that via:
 
 ```
-lhctl get wfSpec my-workflow
+lhctl get wfSpec basic-workflow
 ```
 
 ## Run a `WfRun`
 
 To run a `WfRun`, you can use `lhctl`.
 
 ```
-lhctl run my-workflow name obi-wan
+lhctl run basic-workflow name obi-wan
 ```
 
 It will print out an ID. You can view the status of that `WfRun` via:

sdk-go/examples/basic/deploy/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"context"
-	lh "github.com/littlehorse-enterprises/littlehorse/sdk-go/littlehorse"
+	"github.com/littlehorse-enterprises/littlehorse/sdk-go/littlehorse"
 	"log"
 
 	"github.com/littlehorse-enterprises/littlehorse/sdk-go/examples"
@@ -11,7 +11,7 @@ import (
 
 func main() {
 	_, client := examples.LoadConfigAndClient()
-	wf := lh.NewWorkflow(basic.MyWorkflow, "my-workflow")
+	wf := littlehorse.NewWorkflow(basic.MyWorkflow, basic.WorkflowName)
 	putWf, err := wf.Compile()
 	if err != nil {
 		log.Fatal(err)
@@ -21,5 +21,5 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	lh.PrintProto(resp)
+	littlehorse.PrintProto(resp)
 }

sdk-go/examples/basic/runworkflow/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"github.com/littlehorse-enterprises/littlehorse/sdk-go/examples/basic"
 	"github.com/littlehorse-enterprises/littlehorse/sdk-go/lhproto"
 	"github.com/littlehorse-enterprises/littlehorse/sdk-go/littlehorse"
 	"log"
@@ -23,7 +24,7 @@ func main() {
 	wfId, err := (*client).RunWf(
 		context.Background(),
 		&lhproto.RunWfRequest{
-			WfSpecName: "my-workflow",
+			WfSpecName: basic.WorkflowName,
 			Variables: map[string]*lhproto.VariableValue{
 				"name": {
 					Value: &lhproto.VariableValue_Str{Str: name},

sdk-go/examples/basic/worker/main.go

@@ -11,7 +11,7 @@ import (
 func main() {
 	config, _ := examples.LoadConfigAndClient()
 
-	tw, err := littlehorse.NewTaskWorker(config, basic.Greet, "greet")
+	tw, err := littlehorse.NewTaskWorker(config, basic.Greet, basic.TaskDefName)
 	if err != nil {
 		log.Fatal(err)
 	}

sdk-go/examples/basic/workflow.go

@@ -5,6 +5,9 @@ import (
 	"github.com/littlehorse-enterprises/littlehorse/sdk-go/littlehorse"
 )
 
+const WorkflowName string = "basic-workflow"
+const TaskDefName string = "greet"
+
 func Greet(name string) string {
 	if name == "obi-wan" {
 		return "hello there"
@@ -19,5 +22,5 @@ func MyWorkflow(wf *littlehorse.WorkflowThread) {
 	// Make it searchable
 	nameVar.Searchable()
 
-	wf.Execute("greet", nameVar)
+	wf.Execute(TaskDefName, nameVar)
 }

sdk-go/examples/bytes/README.md

@@ -6,15 +6,15 @@ This is a "hello-world" with bytes example of LittleHorse using GoLang.
 
 The file [workflow.go](./workflow.go) has two functions defined:
 
-- `Greet`, which is a Task Function.
+- `ToBytesLength`, which is a Task Function.
 - `MyWorkflow`, which is the Workflow Function.
 
 ## Deploy the Task Worker
 
 Before we can create the `WfSpec`, we need to register the `TaskDef`. The easiest way to do that is to run the task worker:
 
 ```
-go run ./bytes/worker
+go run ./examples/bytes/worker
 ```
 
 Leave that process running.
@@ -24,21 +24,21 @@ Leave that process running.
 Next, in another terminal, run:
 
 ```
-go run ./bytes/deploy
+go run ./examples/bytes/deploy
 ```
 
 That will create the `WfSpec`. You can verify that via:
 
 ```
-lhctl get wfSpec my-workflow
+lhctl get wfSpec bytes-workflow
 ```
 
 ## Run a `WfRun`
 
 To run a `WfRun`, you can use `lhctl`.
 
 ```
-lhctl run my-workflow
+lhctl run bytes-workflow
 ```
 
 It will print out an ID. You can view the status of that `WfRun` via:

sdk-go/examples/bytes/deploy/main.go

@@ -11,7 +11,7 @@ import (
 
 func main() {
 	_, client := examples.LoadConfigAndClient()
-	wf := littlehorse.NewWorkflow(bytes.MyWorkflow, "my-workflow")
+	wf := littlehorse.NewWorkflow(bytes.MyWorkflow, bytes.WorkflowName)
 	putWf, err := wf.Compile()
 	if err != nil {
 		log.Fatal(err)

sdk-go/examples/bytes/worker/main.go

@@ -11,7 +11,7 @@ import (
 func main() {
 	config, _ := examples.LoadConfigAndClient()
 
-	tw, err := littlehorse.NewTaskWorker(config, bytes.Greet, "greet")
+	tw, err := littlehorse.NewTaskWorker(config, bytes.ToBytesLength, bytes.TaskDefName)
 
 	if err != nil {
 		log.Fatal(err)

sdk-go/examples/bytes/workflow.go

@@ -4,10 +4,13 @@ import (
 	"github.com/littlehorse-enterprises/littlehorse/sdk-go/littlehorse"
 )
 
-func Greet(byteInput []byte) int {
+const WorkflowName string = "bytes-workflow"
+const TaskDefName string = "to-bytes"
+
+func ToBytesLength(byteInput []byte) int {
 	return len(byteInput)
 }
 
 func MyWorkflow(wf *littlehorse.WorkflowThread) {
-	wf.Execute("greet", []byte("hello little horse"))
+	wf.Execute(TaskDefName, []byte("hello little horse"))
 }

sdk-go/examples/childthread/README.md

@@ -7,23 +7,23 @@ This is a simple example of a workflow that launches a Child Thread and waits fo
 We have two `TaskDef`'s and thus two Task Functions. Note that `worker/main.go` kicks off two threads, one for each Task Worker.
 
 ```
-go run ./interrupt/worker
+go run ./examples/childthread/worker
 ```
 
 ## Register the `WfSpec`
 
 In another terminal, run:
 
 ```
-go run ./interrupt/deploy
+go run ./examples/childthread/deploy
 ```
 
 ## Run a `WfRun`
 
 Let's run the `WfRun`:
 
 ```
-lhctl run child-thread input "this is the input!"
+lhctl run child-thread-workflow input "this is the input!"
 ```
 
 You can see both `ThreadRun`s when you inspect the `WfRun`:

sdk-go/examples/childthread/deploy/main.go

@@ -12,7 +12,7 @@ import (
 func main() {
 	_, client := examples.LoadConfigAndClient()
 
-	wf := littlehorse.NewWorkflow(childthread.ChildThreadWorkflow, "child-thread")
+	wf := littlehorse.NewWorkflow(childthread.ChildThreadWorkflow, childthread.WorkflowName)
 	putWf, err := wf.Compile()
 	if err != nil {
 		log.Fatal(err)

sdk-go/examples/childthread/worker/main.go

@@ -14,12 +14,12 @@ func main() {
 	var parentWorker, childWorker *littlehorse.LHTaskWorker
 	var err error
 
-	parentWorker, err = littlehorse.NewTaskWorker(config, childthread.ParentThreadTask, "parent-thread-task")
+	parentWorker, err = littlehorse.NewTaskWorker(config, childthread.ParentThreadTask, childthread.ParentTaskName)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	childWorker, err = littlehorse.NewTaskWorker(config, childthread.ChildThreadTask, "child-thread-task")
+	childWorker, err = littlehorse.NewTaskWorker(config, childthread.ChildThreadTask, childthread.ChildTaskName)
 	if err != nil {
 		log.Fatal(err)
 	}

sdk-go/examples/childthread/workflow.go

@@ -5,6 +5,12 @@ import (
 	"github.com/littlehorse-enterprises/littlehorse/sdk-go/littlehorse"
 )
 
+const (
+	ChildTaskName  string = "child-thread-task"
+	ParentTaskName string = "parent-thread-task"
+	WorkflowName   string = "child-thread-workflow"
+)
+
 func ParentThreadTask() string {
 	return "hello there"
 }
@@ -15,15 +21,14 @@ func ChildThreadTask(input string) string {
 
 func ChildThreadWorkflow(wf *littlehorse.WorkflowThread) {
 	inputVar := wf.AddVariable("input", lhproto.VariableType_STR)
-
 	childThread := wf.SpawnThread(
 		func(child *littlehorse.WorkflowThread) {
-			child.Execute("child-thread-task", inputVar)
+			child.Execute(ChildTaskName, inputVar)
 		},
 		"my-child-thread",
 		nil,
 	)
 
-	wf.Execute("parent-thread-task")
+	wf.Execute(ParentTaskName)
 	wf.WaitForThreads(childThread)
 }

sdk-go/examples/conditionals/ifelse/README.md

@@ -16,15 +16,15 @@ else:
 We have two `TaskDef`'s and thus two Task Functions. Note that `worker/main.go` kicks off two threads, one for each Task Worker.
 
 ```
-go run ./conditionals/ifelse/worker
+go run ./examples/conditionals/ifelse/worker
 ```
 
 ## Register the `WfSpec`
 
 In another terminal, run:
 
 ```
-go run ./conditionals/ifelse/deploy
+go run ./examples/conditionals/ifelse/deploy
 ```
 
 ## Run a `WfRun`
@@ -35,10 +35,15 @@ Let's run the `WfRun` with a small amount of donuts:
 lhctl run donut-workflow number-of-donuts 3
 ```
 
-Let's view the output of the Task
+Let's find and copy the TaskGuid
+```
+lhctl get nodeRun <wfRunId from before> 0 2
+```
+
+Let's view the output of the Task:
 
 ```
-lhctl get nodeRun <wfRunId from before> 0 2 | jq .result.task.output.str
+lhctl get taskRun <wfRunId from before> <taskGuid from before> | jq '.attempts[0].output.str'
 ```
 
 That should print:
@@ -53,10 +58,15 @@ Let's run it after we've had too many donuts:
 lhctl run donut-workflow number-of-donuts 15
 ```
 
-Let's view the output of the Task
+Let's find and copy the TaskGuid
+```
+lhctl get nodeRun <wfRunId from before> 0 2
+```
+
+Let's view the output of the Task:
 
 ```
-lhctl get nodeRun <wfRunId from before> 0 2 | jq .result.task.output.str
+lhctl get taskRun <wfRunId from before> <taskGuid from before> | jq '.attempts[0].output.str'
 ```
 
 That should print:

sdk-go/examples/conditionals/ifelse/deploy/main.go

@@ -11,7 +11,7 @@ import (
 
 func main() {
 	_, client := examples.LoadConfigAndClient()
-	wf := littlehorse.NewWorkflow(ifelse.DonutWorkflow, "donut-workflow")
+	wf := littlehorse.NewWorkflow(ifelse.DonutWorkflow, ifelse.WorkflowName)
 	putWf, err := wf.Compile()
 	if err != nil {
 		log.Fatal(err)

sdk-go/examples/conditionals/ifelse/worker/main.go

@@ -14,12 +14,12 @@ func main() {
 	var saladWorker, donutWorker *littlehorse.LHTaskWorker
 	var err error
 
-	saladWorker, err = littlehorse.NewTaskWorker(config, ifelse.Salad, "eat-salad")
+	saladWorker, err = littlehorse.NewTaskWorker(config, ifelse.Salad, ifelse.EatSaladTaskName)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	donutWorker, err = littlehorse.NewTaskWorker(config, ifelse.Donut, "eat-another-donut")
+	donutWorker, err = littlehorse.NewTaskWorker(config, ifelse.Donut, ifelse.EatAnotherDonutTaskName)
 	if err != nil {
 		log.Fatal(err)
 	}