Add activities and operations sample folders with self-contained workflows

Signed-off-by: Diana Zawadzki <[email protected]>

Author: zawadzkidiana

new_samples/activities/README.md

@@ -0,0 +1,95 @@
+# Activity Samples
+
+This folder contains samples demonstrating different activity patterns in Cadence.
+
+## Samples Included
+
+### 1. Dynamic Workflow
+Demonstrates calling activities by string name instead of function reference.
+
+### 2. Parallel Pick First Workflow
+Demonstrates running multiple activities in parallel and using the first result.
+
+## Prerequisites
+
+1. Run the Cadence server (see [main README](../../README.md))
+2. Register the `cadence-samples` domain:
+
+```bash
+cadence --env development --domain cadence-samples domain register
+```
+
+## Steps to Run
+
+### Start the Worker
+
+```bash
+go run .
+```
+
+This worker handles both workflow types.
+
+---
+
+## Dynamic Workflow
+
+Invoke activities by string name for plugin systems or configuration-driven workflows.
+
+### Start the Workflow
+
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow start \
+  --workflow_type cadence_samples.DynamicWorkflow \
+  --tl cadence-samples-worker \
+  --et 60 \
+  --input '{"message":"Cadence"}'
+```
+
+### Key Concept
+
+```go
+// Instead of: workflow.ExecuteActivity(ctx, MyActivity, input)
+// Use:        workflow.ExecuteActivity(ctx, "activity.name.string", input)
+```
+
+---
+
+## Parallel Pick First Workflow
+
+Run multiple activities in parallel, use the first result, cancel the rest.
+
+### Start the Workflow
+
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow start \
+  --workflow_type cadence_samples.ParallelBranchPickFirstWorkflow \
+  --tl cadence-samples-worker \
+  --et 60 \
+  --input '{}'
+```
+
+### Key Concept
+
+```go
+selector := workflow.NewSelector(ctx)
+selector.AddFuture(f1, handler1)
+selector.AddFuture(f2, handler2)
+selector.Select(ctx)  // Blocks until one completes
+cancelHandler()       // Cancel the rest
+```
+
+---
+
+## View Your Workflows
+
+Open [localhost:8088](http://localhost:8088) and click on `cadence-samples` domain.
+
+## References
+
+- [Cadence Documentation](https://cadenceworkflow.io)
+- [Activity Basics](https://cadenceworkflow.io/docs/concepts/activities/)
+

new_samples/activities/main.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func main() {
+	StartWorker()
+
+	done := make(chan os.Signal, 1)
+	signal.Notify(done, syscall.SIGINT)
+	fmt.Println("Cadence worker started, press ctrl+c to terminate...")
+	<-done
+}
+

new_samples/activities/worker.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"github.com/uber-go/tally"
+	apiv1 "github.com/uber/cadence-idl/go/proto/api/v1"
+	"go.uber.org/cadence/.gen/go/cadence/workflowserviceclient"
+	"go.uber.org/cadence/activity"
+	"go.uber.org/cadence/compatibility"
+	"go.uber.org/cadence/worker"
+	"go.uber.org/cadence/workflow"
+	"go.uber.org/yarpc"
+	"go.uber.org/yarpc/peer"
+	yarpchostport "go.uber.org/yarpc/peer/hostport"
+	"go.uber.org/yarpc/transport/grpc"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+const (
+	HostPort       = "127.0.0.1:7833"
+	Domain         = "cadence-samples"
+	TaskListName   = "cadence-samples-worker"
+	ClientName     = "cadence-samples-worker"
+	CadenceService = "cadence-frontend"
+)
+
+func StartWorker() {
+	logger, cadenceClient := BuildLogger(), BuildCadenceClient()
+	workerOptions := worker.Options{
+		Logger:       logger,
+		MetricsScope: tally.NewTestScope(TaskListName, nil),
+	}
+
+	w := worker.New(
+		cadenceClient,
+		Domain,
+		TaskListName,
+		workerOptions)
+
+	// Dynamic workflow registration
+	w.RegisterWorkflowWithOptions(DynamicWorkflow, workflow.RegisterOptions{Name: "cadence_samples.DynamicWorkflow"})
+	w.RegisterActivityWithOptions(DynamicGreetingActivity, activity.RegisterOptions{Name: DynamicGreetingActivityName})
+
+	// Parallel pick first workflow registration
+	w.RegisterWorkflowWithOptions(ParallelBranchPickFirstWorkflow, workflow.RegisterOptions{Name: "cadence_samples.ParallelBranchPickFirstWorkflow"})
+	w.RegisterActivityWithOptions(ParallelActivity, activity.RegisterOptions{Name: "cadence_samples.ParallelActivity"})
+
+	err := w.Start()
+	if err != nil {
+		panic("Failed to start worker: " + err.Error())
+	}
+	logger.Info("Started Worker.", zap.String("worker", TaskListName))
+}
+
+func BuildCadenceClient(dialOptions ...grpc.DialOption) workflowserviceclient.Interface {
+	grpcTransport := grpc.NewTransport()
+	myChooser := peer.NewSingle(
+		yarpchostport.Identify(HostPort),
+		grpcTransport.NewDialer(dialOptions...),
+	)
+	outbound := grpcTransport.NewOutbound(myChooser)
+
+	dispatcher := yarpc.NewDispatcher(yarpc.Config{
+		Name: ClientName,
+		Outbounds: yarpc.Outbounds{
+			CadenceService: {Unary: outbound},
+		},
+	})
+	if err := dispatcher.Start(); err != nil {
+		panic("Failed to start dispatcher: " + err.Error())
+	}
+
+	clientConfig := dispatcher.ClientConfig(CadenceService)
+
+	return compatibility.NewThrift2ProtoAdapter(
+		apiv1.NewDomainAPIYARPCClient(clientConfig),
+		apiv1.NewWorkflowAPIYARPCClient(clientConfig),
+		apiv1.NewWorkerAPIYARPCClient(clientConfig),
+		apiv1.NewVisibilityAPIYARPCClient(clientConfig),
+	)
+}
+
+func BuildLogger() *zap.Logger {
+	config := zap.NewDevelopmentConfig()
+	config.Level.SetLevel(zapcore.InfoLevel)
+
+	var err error
+	logger, err := config.Build()
+	if err != nil {
+		panic("Failed to setup logger: " + err.Error())
+	}
+
+	return logger
+}
+

new_samples/activities/workflow.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"context"
+	"time"
+
+	"go.uber.org/cadence/activity"
+	"go.uber.org/cadence/workflow"
+	"go.uber.org/zap"
+)
+
+// =============================================================================
+// Dynamic Workflow
+// =============================================================================
+
+// DynamicGreetingActivityName is the registered name for the activity.
+// This demonstrates how to invoke activities by string name rather than function reference.
+const DynamicGreetingActivityName = "cadence_samples.DynamicGreetingActivity"
+
+type dynamicWorkflowInput struct {
+	Message string `json:"message"`
+}
+
+// DynamicWorkflow demonstrates calling activities using string names for dynamic behavior.
+// Instead of passing the function directly to ExecuteActivity, we pass the activity name.
+// This is useful for plugin systems or configuration-driven workflows.
+func DynamicWorkflow(ctx workflow.Context, input dynamicWorkflowInput) (string, error) {
+	ao := workflow.ActivityOptions{
+		ScheduleToStartTimeout: time.Minute,
+		StartToCloseTimeout:    time.Minute,
+	}
+	ctx = workflow.WithActivityOptions(ctx, ao)
+
+	logger := workflow.GetLogger(ctx)
+	logger.Info("DynamicWorkflow started")
+
+	var greetingMsg string
+	// Note: We pass the activity NAME (string) instead of the function reference
+	err := workflow.ExecuteActivity(ctx, DynamicGreetingActivityName, input.Message).Get(ctx, &greetingMsg)
+	if err != nil {
+		logger.Error("DynamicGreetingActivity failed", zap.Error(err))
+		return "", err
+	}
+
+	logger.Info("Workflow result", zap.String("greeting", greetingMsg))
+	return greetingMsg, nil
+}
+
+// DynamicGreetingActivity is a simple activity that returns a greeting message.
+func DynamicGreetingActivity(ctx context.Context, message string) (string, error) {
+	logger := activity.GetLogger(ctx)
+	logger.Info("DynamicGreetingActivity started.")
+	return "Hello, " + message, nil
+}
+
+// =============================================================================
+// Parallel Pick First Workflow
+// =============================================================================
+
+type parallelBranchInput struct {
+	Message string `json:"message"`
+}
+
+// ParallelBranchPickFirstWorkflow demonstrates running multiple activities in parallel
+// and using the result from whichever completes first.
+func ParallelBranchPickFirstWorkflow(ctx workflow.Context) (string, error) {
+	logger := workflow.GetLogger(ctx)
+	logger.Info("ParallelBranchPickFirstWorkflow started")
+
+	selector := workflow.NewSelector(ctx)
+	var firstResp string
+
+	// Use a cancel handler to cancel all remaining activities once one completes
+	childCtx, cancelHandler := workflow.WithCancel(ctx)
+	ao := workflow.ActivityOptions{
+		ScheduleToStartTimeout: time.Minute,
+		StartToCloseTimeout:    time.Minute,
+		HeartbeatTimeout:       time.Second * 20,
+		WaitForCancellation:    true,
+	}
+	childCtx = workflow.WithActivityOptions(childCtx, ao)
+
+	// Run two activities in parallel with different delays
+	f1 := workflow.ExecuteActivity(childCtx, ParallelActivity, parallelBranchInput{Message: "first activity"}, time.Second*10)
+	f2 := workflow.ExecuteActivity(childCtx, ParallelActivity, parallelBranchInput{Message: "second activity"}, time.Second*2)
+	pendingFutures := []workflow.Future{f1, f2}
+
+	selector.AddFuture(f1, func(f workflow.Future) {
+		f.Get(ctx, &firstResp)
+	}).AddFuture(f2, func(f workflow.Future) {
+		f.Get(ctx, &firstResp)
+	})
+
+	// Wait for any of the futures to complete
+	selector.Select(ctx)
+
+	// Cancel all other pending activities
+	cancelHandler()
+
+	// Wait for pending activities to finish cancellation
+	for _, f := range pendingFutures {
+		err := f.Get(ctx, &firstResp)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	logger.Info("ParallelBranchPickFirstWorkflow completed")
+	return firstResp, nil
+}
+
+// ParallelActivity is a simple activity that returns a greeting.
+func ParallelActivity(ctx context.Context, input parallelBranchInput) (string, error) {
+	logger := activity.GetLogger(ctx)
+	logger.Info("ParallelActivity started")
+	return "Hello " + input.Message, nil
+}
+