Signal behavior

[mandeepbrar]

Signal behavior in the below piece of code seems to be a problem. I am running a workflow and want to block it till an external signal is received from a URL (implemented by call to http://localhost:3000/bar/:token) below. If the token (uuid) is passed from startWorkflow function, the code is running well and the blocking behavior is good i.e. workflow moves to Activity1 and executes it. But if the channel name is generated as part of workflow execution, it doesnt work and the workflow remains stuck.

ie.
it works if the following line is there
workflow.NewSignalChannel[int](ctx, chanName).Receive(ctx)

but doesnt work if the chanName in the same line is changed to
workflow.NewSignalChannel[int](ctx, newuid).Receive(ctx)

I am passing the chanName or newuid by copying the relevant signal channel name from the console and pasting it into the browser e.g. http://localhost:3000/bar/d811b2b9-60e1-4bab-bcd1-69ebe92a877a

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"os/signal"

	"github.com/cschleiden/go-workflows/backend"
	"github.com/cschleiden/go-workflows/backend/sqlite"
	"github.com/cschleiden/go-workflows/client"
	"github.com/cschleiden/go-workflows/diag"
	"github.com/cschleiden/go-workflows/worker"
	"github.com/cschleiden/go-workflows/workflow"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

func main() {
	ctx := context.Background()

	b := GetBackend()

	// Run worker
	go RunWorker(ctx, b)

	// Start workflow via client
	c := client.New(b)

	startWorkflow(ctx, c, b)

	c2 := make(chan os.Signal, 1)
	signal.Notify(c2, os.Interrupt)
	<-c2
}

func GetBackend() diag.Backend {
	return sqlite.NewInMemoryBackend()
}

func startWorkflow(ctx context.Context, c *client.Client, b diag.Backend) {
	chanName := uuid.NewString()
	fmt.Println("channel name ", chanName)
	wf, err := c.CreateWorkflowInstance(ctx, client.WorkflowInstanceOptions{
		InstanceID: uuid.NewString(),
	}, Workflow1, "Hello world", chanName)
	if err != nil {
		panic("could not start workflow")
	}

	route := gin.Default()

	route.GET("/bar/:token", func(ctx *gin.Context) {
		log.Println("Started workflow", wf.InstanceID)
		token := ctx.Param("token")

		c.SignalWorkflow(ctx, wf.InstanceID, token, 42)

		fmt.Println("request received")
	})

	//	m.Handle("/diag/", http.StripPrefix("/diag", diag.NewServeMux(b)))

	go route.Run(":3000")

	//	log.Println("Debug UI available at http://localhost:3000/diag")

}

func RunWorker(ctx context.Context, mb backend.Backend) {
	w := worker.New(mb, nil)

	w.RegisterWorkflow(Workflow1)
	w.RegisterActivity(Activity1)
	if err := w.Start(ctx); err != nil {
		panic("could not start worker")
	}
}

func Activity1(ctx context.Context, a, b int) (int, error) {
	fmt.Println("Activity1")
	return a + b, nil
}

func Workflow1(ctx workflow.Context, msg string, chanName string) (string, error) {
	newuid := uuid.NewString()
	fmt.Println("Entering Workflow1  ", newuid)

	workflow.NewSignalChannel[int](ctx, chanName).Receive(ctx)
	fmt.Println("received signal")

	r2, err := workflow.ExecuteActivity[int](ctx, workflow.DefaultActivityOptions, Activity1, 2, 4).Get(ctx)
	if err != nil {
		panic("error getting activity 1 result")
	}

	fmt.Println("next step, wf complete", r2)

	return "result", nil
}

[cschleiden]

You do want to have a well-known name for the signal channel and then send the token as part of the payload. So I'd do something like:

const chanName = "token-signal"


// workflow
token, err := workflow.NewSignalChannel[string](ctx, chanName).Receive(ctx)

// url handler
c.SignalWorkflow(ctx, wf.InstanceID, chanName, token)

[mandeepbrar]

Am trying to simulate BPM user tasks via this mechanism. So the tasks on which i have to wait can not be determined at the design time. If the consuming application wants to put 3 user tasks which have to be completed then there would be 3 ids on which signal has to be received for completion. The design time is unlikely to know the number of user tasks that will be there in the workflow.