Add self-contained samples: cancelactivity, delaystart, dynamic, splitmerge, signalcounter

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

Author: zawadzkidiana

new_samples/cancelactivity/README.md

@@ -0,0 +1,91 @@
+<!-- THIS IS A GENERATED FILE -->
+<!-- PLEASE DO NOT EDIT -->
+
+# Cancel 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
+
+## How It Works
+
+This sample demonstrates graceful workflow cancellation with cleanup:
+
+```
+┌──────────────────────┐
+│   CancelWorkflow     │
+│                      │
+│  ┌────────────────┐  │     Cancel Signal
+│  │ LongRunning    │◀─┼─────────────────────
+│  │ Activity       │  │
+│  │ (heartbeating) │  │
+│  └───────┬────────┘  │
+│          │           │
+│    On Cancel:        │
+│          ▼           │
+│  ┌────────────────┐  │
+│  │ CleanupActivity│  │  ← Runs in disconnected context
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+Key concepts:
+- **WaitForCancellation**: Activity option that waits for activity to acknowledge cancel
+- **NewDisconnectedContext**: Creates a context unaffected by workflow cancellation
+- **IsCanceledError**: Check if an error is due to cancellation
+
+## Running the Sample
+
+Start the worker:
+```bash
+go run .
+```
+
+Trigger a workflow:
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow start \
+  --workflow_type cadence_samples.CancelWorkflow \
+  --tl cadence-samples-worker \
+  --et 600
+```
+
+Cancel the workflow (copy workflow ID from above):
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow cancel \
+  --wid <workflow_id>
+```
+
+Watch the worker logs to see the cleanup activity run.
+
+## 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/cancelactivity/cancelactivity.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go.uber.org/cadence"
+	"go.uber.org/cadence/activity"
+	"go.uber.org/cadence/workflow"
+	"go.uber.org/zap"
+)
+
+/**
+ * This is the cancel activity workflow sample.
+ */
+
+// ApplicationName is the task list for this sample
+const ApplicationName = "cancelGroup"
+
+// CancelWorkflow workflow decider
+func CancelWorkflow(ctx workflow.Context) (retError error) {
+	ao := workflow.ActivityOptions{
+		ScheduleToStartTimeout: time.Minute,
+		StartToCloseTimeout:    time.Minute * 30,
+		HeartbeatTimeout:       time.Second * 5,
+		WaitForCancellation:    true,
+	}
+	ctx = workflow.WithActivityOptions(ctx, ao)
+	logger := workflow.GetLogger(ctx)
+	logger.Info("cancel workflow started")
+
+	defer func() {
+		if cadence.IsCanceledError(retError) {
+			// When workflow is canceled, it has to get a new disconnected context to execute any activities
+			newCtx, _ := workflow.NewDisconnectedContext(ctx)
+			err := workflow.ExecuteActivity(newCtx, CleanupActivity).Get(ctx, nil)
+			if err != nil {
+				logger.Error("Cleanup activity failed", zap.Error(err))
+				retError = err
+				return
+			}
+			retError = nil
+			logger.Info("Workflow completed.")
+		}
+	}()
+
+	var result string
+	err := workflow.ExecuteActivity(ctx, LongRunningActivity).Get(ctx, &result)
+	if err != nil && !cadence.IsCanceledError(err) {
+		logger.Error("Error from LongRunningActivity", zap.Error(err))
+		return err
+	}
+	logger.Info(fmt.Sprintf("LongRunningActivity returns %v, %v", result, err))
+
+	// Execute activity using a canceled ctx,
+	// activity won't be scheduled and an cancelled error will be returned
+	err = workflow.ExecuteActivity(ctx, SkippedActivity).Get(ctx, nil)
+	if err != nil && !cadence.IsCanceledError(err) {
+		logger.Error("Error from SkippedActivity", zap.Error(err))
+	}
+
+	return err
+}
+
+func LongRunningActivity(ctx context.Context) (string, error) {
+	logger := activity.GetLogger(ctx)
+	logger.Info("activity started, to cancel workflow, use ./cancelactivity -m cancel -w <WorkflowID> or CLI: 'cadence --do default wf cancel -w <WorkflowID>' to cancel")
+	for {
+		select {
+		case <-time.After(1 * time.Second):
+			logger.Info("heartbeating...")
+			activity.RecordHeartbeat(ctx, "")
+		case <-ctx.Done():
+			logger.Info("context is cancelled")
+			// returned canceled error here so that in workflow history we can see ActivityTaskCanceled event
+			// or if not cancelled, return timeout error
+			return "I am canceled by Done", ctx.Err()
+		}
+	}
+}
+
+func CleanupActivity(ctx context.Context) error {
+	logger := activity.GetLogger(ctx)
+	logger.Info("CleanupActivity started")
+	return nil
+}
+
+func SkippedActivity(ctx context.Context) error {
+	logger := activity.GetLogger(ctx)
+	logger.Info("this activity will be skipped due to cancellation")
+	return nil
+}

new_samples/cancelactivity/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/cancelactivity/generator/README_specific.md

@@ -0,0 +1,53 @@
+## How It Works
+
+This sample demonstrates graceful workflow cancellation with cleanup:
+
+```
+┌──────────────────────┐
+│   CancelWorkflow     │
+│                      │
+│  ┌────────────────┐  │     Cancel Signal
+│  │ LongRunning    │◀─┼─────────────────────
+│  │ Activity       │  │
+│  │ (heartbeating) │  │
+│  └───────┬────────┘  │
+│          │           │
+│    On Cancel:        │
+│          ▼           │
+│  ┌────────────────┐  │
+│  │ CleanupActivity│  │  ← Runs in disconnected context
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+Key concepts:
+- **WaitForCancellation**: Activity option that waits for activity to acknowledge cancel
+- **NewDisconnectedContext**: Creates a context unaffected by workflow cancellation
+- **IsCanceledError**: Check if an error is due to cancellation
+
+## Running the Sample
+
+Start the worker:
+```bash
+go run .
+```
+
+Trigger a workflow:
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow start \
+  --workflow_type cadence_samples.CancelWorkflow \
+  --tl cadence-samples-worker \
+  --et 600
+```
+
+Cancel the workflow (copy workflow ID from above):
+```bash
+cadence --env development \
+  --domain cadence-samples \
+  workflow cancel \
+  --wid <workflow_id>
+```
+
+Watch the worker logs to see the cleanup activity run.

new_samples/cancelactivity/generator/generate.go

@@ -0,0 +1,12 @@
+package main
+
+import "github.com/uber-common/cadence-samples/new_samples/template"
+
+func main() {
+	data := template.TemplateData{
+		SampleName: "Cancel Activity",
+		Workflows:  []string{"CancelWorkflow"},
+		Activities: []string{"LongRunningActivity", "CleanupActivity", "SkippedActivity"},
+	}
+	template.GenerateAll(data)
+}

new_samples/cancelactivity/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
+}