feat: Restructure activities and operations with generator pattern

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

Author: zawadzkidiana

new_samples/activities/README.md

@@ -0,0 +1,70 @@
+<!-- THIS IS A GENERATED FILE -->
+<!-- PLEASE DO NOT EDIT -->
+
+# Dynamic Activity Sample
+
+## Prerequisites
+
+0. Install Cadence CLI. See instruction [here](https://cadenceworkflow.io/docs/cli/).
+1. Run the Cadence server:
+    1. Clone the [Cadence](https://github.com/cadence-workflow/cadence) repository if you haven't done already: `git clone https://github.com/cadence-workflow/cadence.git`
+    2. Run `docker compose -f docker/docker-compose.yml up` to start Cadence server
+    3. See more details at https://github.com/uber/cadence/blob/master/README.md
+2. Once everything is up and running in Docker, open [localhost:8088](localhost:8088) to view Cadence UI.
+3. Register the `cadence-samples` domain:
+
+```bash
+cadence --env development --domain cadence-samples domain register
+```
+
+Refresh the [domains page](http://localhost:8088/domains) from step 2 to verify `cadence-samples` is registered.
+
+## Steps to run sample
+
+Inside the folder this sample is defined, run the following command:
+
+```bash
+go run .
+```
+
+This will call the main function in main.go which starts the worker, which will be execute the sample workflow code
+
+## Dynamic Activity Workflow
+
+This sample demonstrates invoking activities by string name rather than function reference.
+
+### Start the Workflow
+
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow start \
+  --tl cadence-samples-worker \
+  --et 60 \
+  --workflow_type cadence_samples.DynamicWorkflow \
+  --input '{"message":"Cadence"}'
+```
+
+Verify that your workflow started and completed successfully.
+
+### Key Concept
+
+Instead of passing the function directly:
+```go
+workflow.ExecuteActivity(ctx, MyActivity, input)
+```
+
+Pass the activity name as a string:
+```go
+workflow.ExecuteActivity(ctx, "cadence_samples.DynamicGreetingActivity", input)
+```
+
+This is useful for plugin systems or configuration-driven workflows.
+
+
+## References
+
+* The website: https://cadenceworkflow.io
+* Cadence's server: https://github.com/uber/cadence
+* Cadence's Go client: https://github.com/uber-go/cadence-client
+

new_samples/activities/dynamic_workflow.go

@@ -1,19 +1,25 @@
-package workflows
+package main
 
 import (
 	"context"
+	"time"
+
 	"go.uber.org/cadence/activity"
 	"go.uber.org/cadence/workflow"
 	"go.uber.org/zap"
-	"time"
 )
 
+// 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,
@@ -25,6 +31,7 @@ func DynamicWorkflow(ctx workflow.Context, input dynamicWorkflowInput) (string,
 	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))
@@ -35,8 +42,10 @@ func DynamicWorkflow(ctx workflow.Context, input dynamicWorkflowInput) (string,
 	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
 }
+

new_samples/activities/generator/README.md

@@ -0,0 +1,23 @@
+<!-- THIS IS A GENERATED FILE -->
+<!-- PLEASE DO NOT EDIT -->
+
+# Sample Generator
+
+This folder is NOT part of the actual sample. It exists only for contributors who work on this sample. Please disregard it if you are trying to learn about Cadence.
+
+To create a better learning experience for Cadence users, each sample folder is designed to be self contained. Users can view every part of writing and running workflows, including:
+
+* Cadence client initialization
+* Worker with workflow and activity registrations
+* Workflow starter
+* and the workflow code itself
+
+Some samples may have more or fewer parts depending on what they need to demonstrate.
+
+In most cases, the workflow code (e.g. `workflow.go`) is the part that users care about. The rest is boilerplate needed to run that workflow. For each sample folder, the workflow code should be written by hand. The boilerplate can be generated. Keeping all parts inside one folder gives early learners more value because they can see everything together rather than jumping across directories.
+
+## Contributing
+
+* When creating a new sample, follow the steps mentioned in the README file in the main samples folder.
+* To update the sample workflow code, edit the workflow file directly.
+* To update the worker, client, or other boilerplate logic, edit the generator file. If your change applies to all samples, update the common generator file inside the `template` folder. Edit the generator file in this folder only when the change should affect this sample alone.

new_samples/activities/generator/README_specific.md

@@ -0,0 +1,32 @@
+## Dynamic Activity Workflow
+
+This sample demonstrates invoking activities by string name rather than function reference.
+
+### Start the Workflow
+
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow start \
+  --tl cadence-samples-worker \
+  --et 60 \
+  --workflow_type cadence_samples.DynamicWorkflow \
+  --input '{"message":"Cadence"}'
+```
+
+Verify that your workflow started and completed successfully.
+
+### Key Concept
+
+Instead of passing the function directly:
+```go
+workflow.ExecuteActivity(ctx, MyActivity, input)
+```
+
+Pass the activity name as a string:
+```go
+workflow.ExecuteActivity(ctx, "cadence_samples.DynamicGreetingActivity", input)
+```
+
+This is useful for plugin systems or configuration-driven workflows.
+

new_samples/activities/generator/generate.go

@@ -0,0 +1,17 @@
+package main
+
+import "github.com/uber-common/cadence-samples/new_samples/template"
+
+func main() {
+	// Define the data for Dynamic Activity sample
+	data := template.TemplateData{
+		SampleName: "Dynamic Activity",
+		Workflows:  []string{"DynamicWorkflow"},
+		Activities: []string{"DynamicGreetingActivity"},
+	}
+
+	template.GenerateAll(data)
+}
+
+// Implement custom generator below
+

new_samples/activities/main.go

@@ -0,0 +1,20 @@
+// THIS IS A GENERATED FILE
+// PLEASE DO NOT EDIT
+
+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/parallel_pick_first_workflow.go

@@ -0,0 +1,101 @@
+// THIS IS A GENERATED FILE
+// PLEASE DO NOT EDIT
+
+// Package worker implements a Cadence worker with basic configurations.
+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 identifies set of client workflows, activities, and workers.
+	// It could be your group or client or application name.
+	TaskListName   = "cadence-samples-worker"
+	ClientName     = "cadence-samples-worker"
+	CadenceService = "cadence-frontend"
+)
+
+// StartWorker creates and starts a basic Cadence worker.
+func StartWorker() {
+	logger, cadenceClient := BuildLogger(), BuildCadenceClient()
+	workerOptions := worker.Options{
+		Logger:       logger,
+		MetricsScope: tally.NewTestScope(TaskListName, nil),
+	}
+
+	w := worker.New(
+		cadenceClient,
+		Domain,
+		TaskListName,
+		workerOptions)
+	// HelloWorld workflow registration
+	w.RegisterWorkflowWithOptions(DynamicWorkflow, workflow.RegisterOptions{Name: "cadence_samples.DynamicWorkflow"})
+	w.RegisterActivityWithOptions(DynamicGreetingActivity, activity.RegisterOptions{Name: "cadence_samples.DynamicGreetingActivity"})
+
+	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()
+	// Create a single peer chooser that identifies the host/port and configures
+	// a gRPC dialer with TLS credentials
+	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)
+
+	// Create a compatibility adapter that wraps proto-based YARPC clients
+	// to provide a unified interface for domain, workflow, worker, and visibility APIs
+	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
+}