Cadence Workflow

https://github.com/cadence-workflow/cadence
Admin
Cadence is an open-source workflow orchestration platform for building and running scalable,...
Tokens:102,975
Snippets:696
Trust Score:7.7
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install and start Cassandra with Homebrew

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Installs Cassandra via Homebrew and starts it as a background service.

```bash
brew install cassandra
brew services start cassandra
```

--------------------------------

### Install and start PostgreSQL with Homebrew

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Installs PostgreSQL via Homebrew and starts it as a background service.

```bash
brew install postgres
brew services start postgres
```

--------------------------------

### Install and start MySQL with Homebrew

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Installs MySQL via Homebrew and starts it as a background service.

```bash
brew install mysql
brew services start mysql
```

--------------------------------

### Run local server with SQLite (make install-schema-sqlite, ./cadence-server --zone sqlite start)

Source: https://github.com/cadence-workflow/cadence/blob/master/AGENTS.md

Fastest path to a running local server without Docker: install the SQLite schema, then start the server with the sqlite zone.

```bash
make install-schema-sqlite
```

```bash
./cadence-server --zone sqlite start
```

--------------------------------

### Worker startup output for helloworld

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Example output after starting the helloworld worker. It shows the worker registering the samples-domain and starting both the workflow and activity workers on the helloWorldGroup task list.

```bash
$./bin/helloworld -m worker &
[1] 16520
2021-09-24T21:07:03.242-0700	INFO	common/sample_helper.go:109	Logger created.
2021-09-24T21:07:03.243-0700	DEBUG	common/factory.go:151	Creating RPC dispatcher outbound	{"ServiceName": "cadence-frontend", "HostPort": "127.0.0.1:7933"}
2021-09-24T21:07:03.250-0700	INFO	common/sample_helper.go:161	Domain successfully registered.	{"Domain": "samples-domain"}
2021-09-24T21:07:03.291-0700	INFO	internal/internal_worker.go:833	Started Workflow Worker	{"Domain": "samples-domain", "TaskList": "helloWorldGroup", "WorkerID": "16520@IT-USA-25920@helloWorldGroup"}
2021-09-24T21:07:03.300-0700	INFO	internal/internal_worker.go:858	Started Activity Worker	{"Domain": "samples-domain", "TaskList": "helloWorldGroup", "WorkerID": "16520@IT-USA-25920@helloWorldGroup"}
```

--------------------------------

### Start dependencies with Docker Compose

Source: https://github.com/cadence-workflow/cadence/blob/master/service/worker/README.md

Starts the Cassandra dependency using Docker Compose. Required before installing schemas.

```bash
docker compose -f docker/dev/cassandra.yml up
```

--------------------------------

### Helloworld workflow output

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Example output after starting the helloworld workflow. It shows the workflow executing the helloWorldActivity and completing with the result "Hello Cadence!".

```bash
$./bin/helloworld
2021-09-24T21:07:06.220-0700	INFO	common/sample_helper.go:109	Logger created.
2021-09-24T21:07:06.220-0700	DEBUG	common/factory.go:151	Creating RPC dispatcher outbound	{"ServiceName": "cadence-frontend", "HostPort": "127.0.0.1:7933"}
2021-09-24T21:07:06.226-0700	INFO	common/sample_helper.go:161	Domain successfully registered.	{"Domain": "samples-domain"}
2021-09-24T21:07:06.272-0700	INFO	common/sample_helper.go:195	Started Workflow	{"WorkflowID": "helloworld_75cf142b-c0de-407e-9115-1d33e9b7551a", "RunID": "98a229b8-8fdd-4d1f-bf41-df00fb06f441"}
2021-09-24T21:07:06.347-0700	INFO	helloworld/helloworld_workflow.go:31	helloworld workflow started	{"Domain": "samples-domain", "TaskList": "helloWorldGroup", "WorkerID": "16520@IT-USA-25920@helloWorldGroup", "WorkflowType": "helloWorldWorkflow", "WorkflowID": "helloworld_75cf142b-c0de-407e-9115-1d33e9b7551a", "RunID": "98a229b8-8fdd-4d1f-bf41-df00fb06f441"}
2021-09-24T21:07:06.347-0700	DEBUG	internal/internal_event_handlers.go:489	ExecuteActivity	{"Domain": "samples-domain", "TaskList": "helloWorldGroup", "WorkerID": "16520@IT-USA-25920@helloWorldGroup", "WorkflowType": "helloWorldWorkflow", "WorkflowID": "helloworld_75cf142b-c0de-407e-9115-1d33e9b7551a", "RunID": "98a229b8-8fdd-4d1f-bf41-df00fb06f441", "ActivityID": "0", "ActivityType": "main.helloWorldActivity"}
2021-09-24T21:07:06.437-0700	INFO	helloworld/helloworld_workflow.go:62	helloworld activity started	{"Domain": "samples-domain", "TaskList": "helloWorldGroup", "WorkerID": "16520@IT-USA-25920@helloWorldGroup", "ActivityID": "0", "ActivityType": "main.helloWorldActivity", "WorkflowType": "helloWorldWorkflow", "WorkflowID": "helloworld_75cf142b-c0de-407e-9115-1d33e9b7551a", "RunID": "98a229b8-8fdd-4d1f-bf41-df00fb06f441"}
2021-09-24T21:07:06.513-0700	INFO	helloworld/helloworld_workflow.go:55	Workflow completed.	{"Domain": "samples-domain", "TaskList": "helloWorldGroup", "WorkerID": "16520@IT-USA-25920@helloWorldGroup", "WorkflowType": "helloWorldWorkflow", "WorkflowID": "helloworld_75cf142b-c0de-407e-9115-1d33e9b7551a", "RunID": "98a229b8-8fdd-4d1f-bf41-df00fb06f441", "Result": "Hello Cadence!"}
```

--------------------------------

### Start Cadence servers for multiple region setup

Source: https://github.com/cadence-workflow/cadence/blob/master/service/worker/README.md

Starts Cadence servers for a multiple region setup using the cross_region_cluster zone. The only difference from the xdc setup is the clusterGroupMetadata.clusterRedirectionPolicy, which should be 'selected-apis-forwarding' due to high network overhead.

```bash
./cadence-server --zone cross_region_cluster0 start
```

```bash
./cadence-server --zone cross_region_cluster1 start
```

```bash
./cadence-server --zone cross_region_cluster2 start
```

--------------------------------

### Install schema for each instance

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/howtos/setup-cadence-locally-with-replication.md

Loops the schema installation command until it completes, since Cassandra can take a while to set up.

```bash
until make install-schema-xdc; do sleep 1; done
```

--------------------------------

### Start Cadence server with Cassandra

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Starts the Cadence server with the specified services for Cassandra.

```bash
cd $GOPATH/github.com/cadence-workflow/cadence
./cadence-server start --services=frontend,matching,history,worker
```

--------------------------------

### Install Golang on macOS

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Installs Golang on macOS using Homebrew.

```bash
brew install go
```

--------------------------------

### Start from released docker.tar.gz

Source: https://github.com/cadence-workflow/cadence/blob/master/docker/README.md

Extracts the `docker.tar.gz` release archive and starts the pre-built image with all dependencies.

```bash
tar -xzvf docker.tar.gz
cd docker
docker compose up
```

--------------------------------

### Start Cadence server with PostgreSQL

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Copies the PostgreSQL development config and starts the Cadence server with the specified services.

```bash
cd $GOPATH/github.com/cadence-workflow/cadence
cp config/development_postgres.yaml config/development.yaml
./cadence-server start --services=frontend,matching,history,worker
```

--------------------------------

### Start Cadence server with MySQL

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Copies the MySQL development config and starts the Cadence server with the specified services.

```bash
cd $GOPATH/github.com/cadence-workflow/cadence
cp config/development_mysql.yaml config/development.yaml
./cadence-server start --services=frontend,matching,history,worker
```

--------------------------------

### Start bench worker with built binary

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Build the cadence-bench binary, then start the bench worker. Uses config/bench/development.yaml by default.

```bash
make cadence-bench
```

```bash
./cadence-bench start
```

--------------------------------

### Start Pinot server with Docker Compose

Source: https://github.com/cadence-workflow/cadence/blob/master/schema/pinot/README.md

Starts the Pinot server using Docker Compose. Pinot has 4 components that must be started in order, so some may fail on first attempt; retry or restart failed components.

```bash
docker compose -f ./docker/dev/cassandra-pinot-kafka.yml up
```

--------------------------------

### Start helloworld worker with -m worker

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Starts a worker for the helloworld workflow in the background. The worker registers the samples-domain and starts the workflow and activity workers on the helloWorldGroup task list.

```bash
./bin/helloworld -m worker &
```

--------------------------------

### Start Cassandra dependency (foreground)

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Starts the Cassandra dependency in the foreground. Use CTRL+C to stop it, then run `docker compose -f ./docker/dev/cassandra.yml down` to clean up resources.

```bash
docker compose -f ./docker/dev/cassandra.yml up
```

--------------------------------

### Start Query workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Query workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.query -i 0
```

--------------------------------

### Start Docker with XDC configuration

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/howtos/setup-cadence-locally-with-replication.md

Starts the Cassandra container using the XDC configuration file. Run from the repo's base path.

```bash
docker compose  -f docker/dev/cassandra.yml up -d
```

--------------------------------

### Install schema for localhost development

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/cassandra/README.md

Run `make install-schema` to set up the schema for local development. See CONTRIBUTING for prerequisites.

```makefile
make install-schema
```

--------------------------------

### Build all samples with make bins

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Builds all the Cadence sample binaries. Run this from the root of the sample repository before starting the helloworld worker.

```bash
make bins
```

--------------------------------

### Start Cadence backend with Docker Compose

Source: https://github.com/cadence-workflow/cadence/blob/master/README.md

Starts all Cadence backend components (services, database, and optional Kafka/Elasticsearch) locally using Docker Compose. Run this from the repository root before starting workers or triggering workflows.

```bash
docker compose -f docker/docker-compose.yml up
```

--------------------------------

### Install schemas for XDC

Source: https://github.com/cadence-workflow/cadence/blob/master/service/worker/README.md

Installs the database schemas needed for cross-datacenter replication.

```bash
make install-schema-xdc
```

--------------------------------

### Start basic load test workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Starts the basic load test workflow. Replace <domain> with a domain from the bench config (e.g., cadence-bench).

```bash
cadence --do <domain> wf start --tl cadence-bench-tl-0 --wt basic-load-test-workflow --dt 30 --et 3600 --if config/bench/basic.json
```

--------------------------------

### Start timer load test workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Starts the timer load test workflow. Requires a domain and the sample configuration file config/bench/timer.json.

```bash
cadence --do <domain> wf start --tl cadence-bench-tl-0 --wt timer-load-test-workflow --dt 30 --et 3600 --if config/bench/timer.json 
```

--------------------------------

### One-time schema setup for cadence and visibility

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/cassandra/README.md

Sets up schema version tables and upgrades to the latest version for both cadence and cadence_visibility keyspaces.

```bash
./cadence-cassandra-tool -ep 127.0.0.1 -k cadence setup-schema -v 0.0 # this sets up just the schema version tables with initial version of 0.0
./cadence-cassandra-tool -ep 127.0.0.1 -k cadence update-schema -d ./schema/cassandra/cadence/versioned # upgrades your schema to the latest version

./cadence-cassandra-tool -ep 127.0.0.1 -k cadence_visibility setup-schema -v 0.0 # this sets up just the schema version tables with initial version of 0.0 for visibility
./cadence-cassandra-tool -ep 127.0.0.1 -k cadence_visibility update-schema -d ./schema/cassandra/visibility/versioned # upgrades your schema to the latest version for visibility
```

--------------------------------

### Start and observe Echo workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Start the Echo workflow and observe its progress. The first command starts the workflow; the second observes it using the workflow ID from the start command output.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.echo -i 0
```

```shell
cadence --do cadence-canary workflow ob -w <...workflowID form the start command output>
```

--------------------------------

### Start helloworld workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Starts a helloworld workflow. Run this after the worker is running to execute the workflow and see the result.

```bash
./bin/helloworld
```

--------------------------------

### Custom query key and value macros with ProcessQueryKey and ProcessQueryValue

Source: https://github.com/cadence-workflow/cadence/blob/master/common/elasticsearch/esql/README.md

Demonstrates registering custom policies for column name replacement and value processing. The key policy replaces column names starting with 'col' with 'myCol' prefix, and the value policy converts formatted time strings to Unix nano integers. The example shows the full setup and conversion, with the resulting DSL equivalent to a query with transformed column names and time value.

```go
sql := "SELECT colA FROM myTable WHERE colB < 10 AND dateTime = '2015-01-01T02:59:59Z'"
// custom policy that change colName like "col.." to "myCol.."
func myKeyFilter(colName string) bool {
    return strings.HasPrefix(colName, "col")
}
func myKeyProcess(colName string) (string, error) {
    return "myCol"+colName[3:], nil
}
// custom policy that convert formatted time string to unix nano
func myValueFilter(colName string) bool {
    return strings.Contains(colName, "Time") || strings.Contains(colName, "time")
}
func myValueProcess(timeStr string) (string, error) {
    // convert formatted time string to unix nano integer
    parsedTime, _ := time.Parse(defaultDateTimeFormat, timeStr)
    return fmt.Sprintf("%v", parsedTime.UnixNano()), nil
}
// with the 2 policies , converted dsl is equivalent to
// "SELECT myColA FROM myTable WHERE myColB < 10 AND dateTime = '1561678568048000000'
// in which the time is in unix nano format
e := NewESql()
e.ProcessQueryKey(myKeyFilter, myKeyProcess)            // set up macro for key
e.ProcessQueryValue(myValueFilter, myValueProcess)      // set up macro for value
dsl, _, err := e.ConvertPretty(sql)                     // convert sql to dsl
if err == nil {
    fmt.Println(dsl)
}
```

--------------------------------

### Install Cadence schema for MySQL

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Installs the Cadence schema for MySQL.

```bash
cd $GOPATH/github.com/cadence-workflow/cadence
make install-schema-mysql
```

--------------------------------

### Install Cadence schema for PostgreSQL

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Installs the Cadence schema for PostgreSQL.

```bash
cd $GOPATH/github.com/cadence-workflow/cadence
make install-schema-postgres
```

--------------------------------

### View Cassandra full query logs with docker and fqltool

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/howtos/cassandra-fql.md

Steps to view Cassandra full query logs: start Cadence components via docker compose, enable FQL with nodetool, verify the log directory, and dump the logs with fqltool. The fqltool is located under tools/bin in a default Apache Cassandra installation.

```bash
docker compose docker/docker-compose.yml up
```

```bash
docker exec $(docker inspect --format="{{.Id}}" docker-cassandra-1) nodetool enablefullquerylog --path /tmp/cassandra_fql
```

```bash
docker exec $(docker inspect --format="{{.Id}}" docker-cassandra-1) ls /tmp/cassandra_fql
```

```bash
docker cp $(docker inspect --format="{{.Id}}" docker-cassandra-1):/tmp/cassandra_fql/ /tmp/cassandra_fql/ && fqltool dump /tmp/cassandra_fql | less
```

--------------------------------

### Start LocalActivity workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the LocalActivity workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.localactivity -i 0
```

--------------------------------

### Start Visibility workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Visibility workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.visibility -i 0
```

--------------------------------

### Start Cassandra dependency (background)

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Starts the Cassandra dependency in the background. Use `docker compose -f ./docker/dev/cassandra.yml down` to stop and clean up resources.

```bash
docker compose -f ./docker/dev/cassandra.yml up -d
```

--------------------------------

### Start workflow with search attributes

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/visibility-on-elasticsearch.md

Start a workflow with search attributes. Note: without ElasticSearch, the workflow starts normally but is not searchable and not shown in list results.

```bash
cadence --do samples-domain workflow start --tl helloWorldGroup --wt main.Workflow --et 60 --dt 10 -i '"input arg"' -search_attr_key 'CustomIntField | CustomKeywordField | CustomStringField |  CustomBoolField | CustomDatetimeField' -search_attr_value '5 | keyword1 | my test | true | 2019-06-07T16:16:36-08:00'
```

--------------------------------

### Install Cadence CLI with Homebrew

Source: https://github.com/cadence-workflow/cadence/blob/master/README.md

Installs the Cadence CLI and schema tools (cadence-sql-tool and cadence-cassandra-tool) via Homebrew. The schema files are placed in /usr/local/etc/cadence/schema/.

```bash
brew install cadence-workflow
```

--------------------------------

### Start Reset workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Reset workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.reset -i 0
```

--------------------------------

### Install Cadence schema for Cassandra

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/persistence.md

Installs the Cadence schema for Cassandra. Requires the make command prerequisites from CONTRIBUTING.md.

```bash
cd $GOPATH/github.com/cadence-workflow/cadence
make install-schema
```

--------------------------------

### Start Cadence development servers for clusters

Source: https://github.com/cadence-workflow/cadence/blob/master/service/worker/README.md

Starts the Cadence development server for cluster0, cluster1, and cluster2 using the xdc_cluster zone.

```bash
./cadence-server --zone xdc_cluster0 start
```

```bash
./cadence-server --zone xdc_cluster1 start
```

```bash
./cadence-server --zone xdc_cluster2 start
```

--------------------------------

### Go Workflow Example with Activities and Timers

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/non-deterministic-error.md

Workflow code that executes activityA, sleeps for 1 minute, executes activityB with the result of activityA, then sleeps for 1 hour. Uses workflow.ActivityOptions and workflow.ExecuteActivity.

```go
func Workflow(ctx workflow.Context) error {
	ao := workflow.ActivityOptions{
		...
	}
	ctx = workflow.WithActivityOptions(ctx, ao)
	var a int
	err := workflow.ExecuteActivity(ctx, activityA).Get(ctx, &a)
	if err != nil {
		return err
	}
	workflow.Sleep(time.Minute)
	err = workflow.ExecuteActivity(ctx, activityB, a).Get(ctx, nil)
	if err != nil {
		return err
	}
	workflow.Sleep(time.Hour)
	return nil
}
```

--------------------------------

### Start Cancellation workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Cancellation workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.cancellation -i 0
```

--------------------------------

### Start signal load test workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Starts the signal load test workflow using the cadence-bench domain.

```bash
cadence --do cadence-bench wf start --tl cadence-bench-tl-0 --wt signal-load-test-workflow --dt 30 --et 3600 --if config/bench/signal.json  
```

--------------------------------

### Manifest.json Example for Schema Version 0.1

Source: https://github.com/cadence-workflow/cadence/blob/master/schema/cassandra/README.md

Shows the format of manifest.json, including CurrVersion, MinCompatibleVersion, Description, and SchemaUpdateCqlFiles fields.

```json
```
{
    "CurrVersion": "0.1",
    "MinCompatibleVersion": "0.1",
    "Description": "base version of schema",
    "SchemaUpdateCqlFiles": [
        "base.cql"
    ]
}
```
```

--------------------------------

### Start cancellation load test workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Starts the cancellation load test workflow. Replace <domain> with a valid domain.

```bash
cadence --do <domain> wf start --tl cadence-bench-tl-0 --wt cancellation-load-test-workflow --dt 30 --et 3600 --if config/bench/cancellation.json 
```

--------------------------------

### Start ConcurrentExec workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the ConcurrentExec workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.concurrent-execution -i 0
```

--------------------------------

### Start Signal workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Signal workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.signal -i 0
```

--------------------------------

### Start Timeout workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Timeout workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.timeout -i 0
```

--------------------------------

### Start concurrent execution test workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Starts the concurrent execution load test workflow. Requires a domain and the sample configuration file config/bench/concurrent_execution.json.

```bash
cadence --do <domain> wf start --tl cadence-bench-tl-0 --wt concurrent-execution-test-workflow --dt 30 --et 3600 --if config/bench/concurrent_execution.json
```

--------------------------------

### Start Cron test workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/bench/README.md

Starts the Cron workflow that runs all other tests according to a schedule. Requires a domain and the sample configuration file config/bench/cron.json.

```bash
cadence --do <domain> wf start --tl cadence-bench-tl-0 --wt cron-test-workflow --dt 30 --et 7200 --if config/bench/cron.json
```

--------------------------------

### Start SearchAttributes workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the SearchAttributes workflow test case. Requires advanced visibility feature configured on the server.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.searchAttributes -i 0
```

--------------------------------

### Show help for describe command

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/migration/tasklist-partition-config.md

Displays help for the 'cadence admin tasklist describe' command, which is used to get the number of partitions from the database.

```bash
cadence admin tasklist describe -h
```

--------------------------------

### Start canary worker and cron

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Start the canary worker and cron using the default configuration. This is equivalent to running with -mode all.

```bash
./cadence-canary start
```

--------------------------------

### Install MySQL schema for localhost development

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/sql/README.md

Installs the MySQL schema for localhost development. Requires the make command prerequisites described in CONTRIBUTING.md.

```bash
SQL_USER=$USERNAME SQL_PASSWORD=$PASSWD make install-schema-mysql
```

--------------------------------

### Start Batch workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Batch workflow test case. Requires advanced visibility feature configured on the server.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.batch -i 0
```

--------------------------------

### Register a domain

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Registers a domain named `samples-domain` after starting the local Cadence server.

```bash
./cadence --do samples-domain domain register
```

--------------------------------

### Start local Cadence cluster with async workflow queue enabled

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/howtos/async-api.md

Starts the Cadence server, UI, Kafka, Cassandra, Prometheus, and Grafana containers using Docker Compose. The environment variables ASYNC_WF_KAFKA_QUEUE_ENABLED, ASYNC_WF_KAFKA_QUEUE_TOPIC, KAFKA_SEEDS, and KAFKA_PORT are set in the compose file. Wait for containers to be ready before proceeding.

```bash
docker compose -f docker/docker-compose-async-wf-kafka.yml up
```

--------------------------------

### Start Cadence instances for each cluster

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/howtos/setup-cadence-locally-with-replication.md

Starts each of the three Cadence instances in separate terminal windows or tmux sessions.

```bash
./cadence-server --config config --zone xdc --env development_xdc_cluster0 start
```

```bash
./cadence-server --config config --zone xdc --env development_xdc_cluster1 start
```

```bash
./cadence-server --config config --zone xdc --env development_xdc_cluster2 start
```

--------------------------------

### Create databases for new cluster

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/sql/README.md

Creates the cadence and cadence_visibility databases for a new cluster. Uses MySQL as an example; for Postgres, use --plugin postgres.

```bash
./cadence-sql-tool --ep $SQL_HOST_ADDR -p $port --plugin mysql create-database --db cadence
./cadence-sql-tool --ep $SQL_HOST_ADDR -p $port --plugin mysql create-database --db cadence_visibility
```

--------------------------------

### MongoDB JSON schema example with create, createIndexes, and insert commands

Source: https://github.com/cadence-workflow/cadence/blob/master/schema/mongodb/README.md

Example schema JSON file containing three commands: create a collection, create an index on fieldnamea and fieldnameb, and insert three documents with ordered set to false.

```json
[
  {
    "create": "collection_name"
  },
  {
    "createIndexes": "collection_name",
    "indexes": [
      {
        "key": {
          "fieldnamea": 1,
          "fieldnameb": -1
        },
        "name": "fieldnamea_fieldnameb"
      }
    ],
    "writeConcern": { "w": "majority" }
  },
  {
    "insert": "collection_name",
    "documents": [
      {
        "fieldnamea": 1,
        "fieldnameb": 0,
        "fieldnamec": "1234"
      },
      {
        "fieldnamea": 2,
        "fieldnameb": 1,
        "fieldnamec": "12344"
      },
      {
        "fieldnamea": 2,
        "fieldnameb": 2,
        "fieldnamec": "12345"
      }
    ],
    "ordered": false
  }
]
```

--------------------------------

### Set up local Cadence Docker with ElasticSearch

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/visibility-on-elasticsearch.md

Commands to set up local Cadence Docker with ElasticSearch: download the compose file, start the stack, clean up disk space if needed, and register a local domain.

```bash
curl -O https://raw.githubusercontent.com/uber/cadence/master/docker/docker-compose-es.yml
```

```bash
docker compose -f docker-compose-es.yml up
```

```bash
docker system prune -a --volumes
```

```bash
cadence --do samples-domain d re
```

--------------------------------

### Start HistoryArchival workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the HistoryArchival test case. Always uses the canary-archival-domain domain. Requires history archival feature configured on the server.

```shell
cadence --do canary-archival-domain workflow start --tl canary-task-queue --et 10 --wt workflow.timeout -i 0
```

--------------------------------

### Get help for unsupported-workflow command

Source: https://github.com/cadence-workflow/cadence/blob/master/RELEASES.md

Use this help command to see configuration options for TLS and customized encoding/decoding types.

```bash
cadence adm db unsupported-workflow --help
```

--------------------------------

### Run custom cadence server locally

Source: https://github.com/cadence-workflow/cadence/blob/master/docker/README.md

Starts Docker compose, stops the cadence server container, and runs the custom-built cadence-server binary locally alongside other dependencies.

```bash
docker compose up
docker stop docker-cadence-1
./cadence-server start
```

--------------------------------

### Describe a domain with Cadence CLI

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/cli/README.md

Use the domain describe command to get details about a specific domain, here 'samples-domain'.

```bash
./cadence --domain samples-domain domain describe
```

--------------------------------

### Cadence workflow show command example

Source: https://github.com/cadence-workflow/cadence/blob/master/common/archiver/gcloud/README.md

Command to retrieve workflow history using a workflow ID and run ID.

```bash
./cadence --do samples-domain  workflow  show  -w workflow-id -r runId
```

--------------------------------

### Start cron canary with worker for local development

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Command to start cron canary workflows along with the worker for local development. Uses the -m all flag.

```bash
 ./cadence-canary start -m all
```

--------------------------------

### List workflows with new visibility API

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/visibility-on-elasticsearch.md

New list API examples using the -q flag to filter workflows by WorkflowType, WorkflowID, RunID, StartTime, and CloseTime. Add CloseTime = missing to list only open workflows.

```bash
cadence --do samples-domain wf list -q 'WorkflowType = "main.Workflow" and (WorkflowID = "1645a588-4772-4dab-b276-5f9db108b3a8" or RunID = "be66519b-5f09-40cd-b2e8-20e4106244dc")'
```

```bash
cadence --do samples-domain wf list -q 'WorkflowType = "main.Workflow" StartTime > "2019-06-07T16:46:34-08:00" and CloseTime = missing'
```

--------------------------------

### Delete wrong ElasticSearch index

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Deletes the wrong ElasticSearch index created on demand when starting the server before installing the ES v7 schema. Run this before re-running `make install-schema-es-v7`.

```bash
curl -X DELETE "http://127.0.0.1:9200/cadence-visibility-dev"
```

--------------------------------

### Initial failover versions for three clusters

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/design/domain-updates/fencing-tokens.md

Example initial-failover-versions for clusters A, B, and C, used as cluster identifiers in the failover version counter.

```text
clusterA: 0
clusterB: 1
clusterC: 2
```

--------------------------------

### Start canary with all modes explicitly

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Explicitly start the canary worker and cron in all modes. This is essentially the same as the default start command.

```bash
./cadence-canary start -mode all
```

--------------------------------

### Run a specific test case with go test

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Runs a specific test case from the command line. The example targets TestListClosedWorkflowExecutions in the TestVisibilitySamplingSuite.

```go
go test -v <path> -run <TestSuite> -testify.m <TestSpercificTaskName>
# example:
go test -v github.com/uber/cadence/common/persistence/persistence-tests -run TestVisibilitySamplingSuite -testify.m TestListClosedWorkflowExecutions
```

--------------------------------

### Register global domain with access point archival URI

Source: https://github.com/cadence-workflow/cadence/blob/master/common/archiver/s3store/README.md

Example command to register a global domain using an s3-ap access point URI. The same URI works in every region.

```bash
cadence --do my-domain domain register \
  --history_uri    "s3-ap://710914175400/cadence-archival/prod" \
  --visibility_uri "s3-ap://710914175400/cadence-archival/prod" \
  --history_archival_status enabled \
  --visibility_archival_status enabled \
  --gd true --cl primary,secondary --ac primary --rd 7
```

--------------------------------

### Pagination with FROM and search_after

Source: https://github.com/cadence-workflow/cadence/blob/master/common/elasticsearch/esql/README.md

Shows two pagination methods: using the FROM keyword for the second page (limited to offsets under 10k) and using search_after with page tokens. The example retrieves the first page, then shows both approaches for the second page, passing sort fields and page tokens to ConvertPretty.

```go
// first page
sql_page1 := "SELECT * FROM myTable ORDER BY colA, colB LIMIT 10"
e := NewESql()
dsl_page1, sortFields, err := e.ConvertPretty(sql_page1)

// second page
// 1. Use FROM to retrieve the 2nd page
sql_page2_FROM := "SELECT * FROM myTable ORDER BY colA, colB LIMIT 10 FROM 10"
dsl_page2_FROM, sortFields, err := e.ConvertPretty(sql_page2_FROM)

// 2. Use search_after to retrieve the 2nd page
// we can use sortFields and the query result from page 1 to get the page tokens
sql_page2_search_after := sql_page1
page_token_colA := "123"
page_token_colB := "bbc"
dsl_page2_search_after, sortFields, err := e.ConvertPretty(sql_page2_search_after, page_colA, page_colB)
```

--------------------------------

### Build test Docker images

Source: https://github.com/cadence-workflow/cadence/blob/master/docker/github_actions/README.md

Build the Docker images for the unit, integration, and cross DC integration tests. The unit-test build may fail on TestServerStartup because the schema is not installed locally as it is in pipeline.yml.

```bash
docker compose -f docker/github_actions/docker-compose-local.yml build unit-test
```

```bash
docker compose -f docker/github_actions/docker-compose-local.yml build integration-test-cassandra
```

```bash
docker compose -f docker/github_actions/docker-compose-local.yml build integration-test-ndc-cassandra
```

--------------------------------

### Cadence workflow listarchived command example

Source: https://github.com/cadence-workflow/cadence/blob/master/common/archiver/gcloud/README.md

Command to search archived visibility records for a given day, using the -ps flag for page size and -q for the SQL-like query. The query requires StartTime or CloseTime and SearchPrecision.

```bash
./cadence --do samples-domain workflow listarchived -ps="20" -q "StartTime = '2020-01-21T00:00:00Z' AND SearchPrecision='Day'"
```

--------------------------------

### Enable async APIs for the domain

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/howtos/async-api.md

Configures the test-domain to use queue1 as the async workflow queue by updating the async workflow queue settings. If you get a 'Domain update too frequent.' error, wait a minute and retry.

```bash
docker run -t --rm --network host ubercadence/cli:master \
    --address localhost:7933 \
    --domain test-domain \
    admin async-wf-queue update \
    --json "{\"PredefinedQueueName\":\"queue1\", \"Enabled\": true}"
```

--------------------------------

### Start canary worker only

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Start only the canary worker for manual testing of certain cases.

```bash
./cadence-canary start -mode worker
```

--------------------------------

### Build auto-setup Docker image

Source: https://github.com/cadence-workflow/cadence/blob/master/docker/README.md

Builds a Cadence server Docker image with the auto-setup target, which sets up all DB/ElasticSearch schema during startup. Requires a checkout branch and replaces the tag in docker-compose.yml.

```bash
cd $GOPATH/src/github.com/uber/cadence
git checkout YOUR_CHECKOUT_BRANCH
docker build . -t ubercadence/server:YOUR_TAG-auto-setup --build-arg TARGET=auto-setup
```

--------------------------------

### Start Retry workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Manually start one run of the Retry workflow test case.

```shell
cadence --do <> workflow start --tl canary-task-queue --et 10 --wt workflow.retry -i 0
```

--------------------------------

### Update master-auto-setup image

Source: https://github.com/cadence-workflow/cadence/blob/master/docker/README.md

Pulls the latest `ubercadence/server:master-auto-setup` image to update to the latest version.

```bash
docker pull ubercadence/server:master-auto-setup
```

--------------------------------

### Basic SQL to DSL conversion with ConvertPretty

Source: https://github.com/cadence-workflow/cadence/blob/master/common/elasticsearch/esql/README.md

Shows how to create an ESQL instance and convert a SQL query with aggregation, filtering, grouping, and HAVING to Elasticsearch DSL. The ConvertPretty method returns the DSL string and an error; if successful, the DSL is printed.

```go
sql := `SELECT COUNT(*), MAX(colA) FROM myTable WHERE colB < 10 GROUP BY colC HAVING COUNT(*) > 20`
e := NewESql()
dsl, _, err := e.ConvertPretty(sql)    // convert sql to dsl
if err == nil {
    fmt.Println(dsl)
}
```

--------------------------------

### Build cadence-canary binary

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Build the cadence canary binary from the project root.

```bash
make cadence-canary
```

--------------------------------

### Run all scenarios and compare

Source: https://github.com/cadence-workflow/cadence/blob/master/simulation/matching/comparison/README.md

Run the comparison tool for all scenarios. The command uses the Go run command with a wildcard to include all Go files in the comparison directory.

```bash
go run simulation/matching/comparison/*.go
```

--------------------------------

### Run help command with local build

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/cli/README.md

Run the help command to see available options and commands for the Cadence CLI.

```bash
./cadence --help
```

--------------------------------

### Build cadence-sql-tool

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/sql/README.md

Builds the cadence-sql-tool binary from source. Requires the make command prerequisites described in CONTRIBUTING.md.

```bash
make cadence-sql-tool
```

--------------------------------

### Start sanity workflow one-off run

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Command to start the sanity workflow as a one-off run. Tasklist is fixed to canary-task-queue, execution timeout recommended 1200 seconds, and input is a scheduled unix timestamp (0 uses workflow starting time).

```bash
cadence --do <the domain you configured> workflow start --tl canary-task-queue --et 1200 --wt workflow.sanity -i 0
```

--------------------------------

### Build Cadence binaries

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Initializes submodules and compiles the cadence service and helper tools without running tests. Produces binaries: cadence-server, cadence, cadence-cassandra-tool, cadence-sql-tool, cadence-canary, and cadence-bench.

```bash
git submodule update --init --recursive

make bins
```

--------------------------------

### Build the Cadence MCP server executable

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/mcp/README.md

Builds the MCP server executable into the .bin directory. Run this from the repository root before configuring Cursor.

```bash
mkdir -p .bin && go build -o .bin/cadence_mcp tools/mcp/main.go
```

--------------------------------

### Download Go dependencies

Source: https://github.com/cadence-workflow/cadence/blob/master/CONTRIBUTING.md

Downloads the Golang dependencies for the Cadence repository.

```bash
go mod download
```

--------------------------------

### Start cron canary workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Command to start the cron canary workflow, which periodically runs the sanity suite. The workflowID is fixed to "cadence.canary.cron". Changing the schedule requires manually terminating the existing cron workflow.

```bash
 ./cadence-canary start -mode cronCanary
```

--------------------------------

### Example reset command for unsupported workflow

Source: https://github.com/cadence-workflow/cadence/blob/master/RELEASES.md

Example CLI command to reset an unsupported workflow to the last decision task completed event. Replace the placeholders with your Cadence host, port, domain, workflow ID, and run ID.

```bash
cadence --address <host>:<port> --domain <ee7316ab-2e42-4f3c-86ee-344a4299791c> workflow reset --wid helloworld_7f2fa1fe-594e-44ad-a9e2-7ac7c5f97861 --rid e79ce972-b657-48a4-bba9-e2f2ac6424e2 --reset_type LastDecisionCompleted --reason 'release 0.16 upgrade'
```

--------------------------------

### Build Cadence CLI with make

Source: https://github.com/cadence-workflow/cadence/blob/master/README.md

Builds the Cadence CLI binary and all tools from the repository source. Requires the prerequisites listed in CONTRIBUTING.md.

```bash
make cadence
```

--------------------------------

### Cadence workflow listarchived query example

Source: https://github.com/cadence-workflow/cadence/blob/master/common/archiver/s3store/README.md

Example of querying archived workflows for a specific day and workflow ID. Uses the `cadence workflow listarchived` command with the `-q` flag. The query requires WorkflowID or WorkflowTypeName and uses StartTime with SearchPrecision='Day'.

```bash
./cadence --do samples-domain workflow listarchived -q "StartTime = '2020-01-21T00:00:00Z' AND WorkflowID='workflow-id' AND SearchPrecision='Day'"
```

--------------------------------

### Run basic simulation tests

Source: https://github.com/cadence-workflow/cadence/blob/master/simulation/README.md

Commands to run basic replication, matching, and history simulation tests using the run.sh scripts with the --scenario flag.

```bash
# Run a basic replication test
./simulation/replication/run.sh --scenario default

# Run a matching performance test
./simulation/matching/run.sh --scenario throughput

# Run a history analysis test
./simulation/history/run.sh --scenario default
```

--------------------------------

### Update schema as part of a release

Source: https://github.com/cadence-workflow/cadence/blob/master/tools/cassandra/README.md

Upgrades to a specific version, with dryrun option. Only possible after initial setup.

```bash
./cadence-cassandra-tool -ep 127.0.0.1 -k cadence update-schema -d ./schema/cassandra/cadence/versioned -v x.xx -dryrun # executes a dryrun of upgrade to version x.xx
./cadence-cassandra-tool -ep 127.0.0.1 -k cadence update-schema -d ./schema/cassandra/cadence/versioned -v x.xx # actually executes the upgrade to version x.xx

./cadence-cassandra-tool -ep 127.0.0.1 -k cadence_visibility update-schema -d ./schema/cassandra/visibility/versioned -v x.xx --dryrun # executes a dryrun of upgrade to version x.xx
./cadence-cassandra-tool -ep 127.0.0.1 -k cadence_visibility update-schema -d ./schema/cassandra/visibility/versioned -v x.xx  # actually executes the upgrade to version x.xx
```

--------------------------------

### Remove existing MySQL containers

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/setup/MYSQL_SETUP.md

Lists all containers and kills/removes any MySQL containers to ensure a clean setup.

```bash
docker ps -a
docker kill <container_id> && docker rm <container_id> # remove any MySQL containers.
```

--------------------------------

### Get generated root password

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/setup/MYSQL_SETUP.md

Retrieves the auto-generated root password from the container logs using grep.

```bash
docker logs mysql1 2>&1 | grep GENERATED
# The result looks like: [Entrypoint] GENERATED ROOT PASSWORD: iHqEvRYm6UP#YN$es;YnV3m(oJ
```

--------------------------------

### Restart services after changing image tag

Source: https://github.com/cadence-workflow/cadence/blob/master/docker/README.md

Stops and removes all containers, then starts them again, after updating the image tag in docker-compose.yml.

```bash
docker compose down
docker compose up
```

--------------------------------

### Run subset of scenarios and compare

Source: https://github.com/cadence-workflow/cadence/blob/master/simulation/matching/comparison/README.md

Run the comparison tool for a specified subset of scenarios using the --scenarios flag. The flag value is a comma-separated list of scenario names.

```bash
go run simulation/matching/comparison/*.go \
    --scenarios "fluctuating"
```

--------------------------------

### Observe sanity workflow progress

Source: https://github.com/cadence-workflow/cadence/blob/master/canary/README.md

Command to observe the progress of a sanity workflow. Use the workflowID from the start command output.

```bash
cadence --do cadence-canary workflow ob -w <...workflowID form the start command output>
```

--------------------------------

### Run development commands (make bins, build, pr, test, lint)

Source: https://github.com/cadence-workflow/cadence/blob/master/AGENTS.md

Core development commands for building, testing, and linting the Cadence codebase. `make pr` runs tidy → go-generate → fmt → lint and is required before every PR; use `make pr GEN_DIR=<package>` for faster scoped codegen. `make test` excludes host/integration tests, while `make test_e2e` requires Docker dependencies running.

```bash
make bins   # build all binaries
make build  # compile-check all packages + test files (no codegen, no test execution)
make pr     # pre-PR: tidy → go-generate → fmt → lint
make pr GEN_DIR=service/history  # scoped codegen (faster for single package)
make test   # all unit tests (excludes host/ integration tests)
make test_e2e  # end-to-end integration tests in host/ (requires Docker dependencies running)
make lint   # lint only
make go-generate  # regenerate mocks, enums, wrapper files

go test -race -run TestFoo ./path/to/pkg/...  # run a specific test
```

--------------------------------

### Run MySQL container with port mapping

Source: https://github.com/cadence-workflow/cadence/blob/master/docs/setup/MYSQL_SETUP.md

Starts a detached container named 'mysql1' with port 3306 exposed locally.

```bash
docker run -p 3306:3306 --name=mysql1 -d mysql/mysql-server:8.0
```
Tokens:
Raw