前身 cadence 的文档 - Cadence 业务引入简析 - 《Temporal 文档教程 - 帮助手册》

Refer
Prequire
Step
Analytics

Refer

Cadence 的各种概念

该示例的工作流会提交一个账单请求到另一个面板等待请求允许或者拒绝。但是活动 activity 并不会等待批准，而是通过返回一个特殊错误来完成这一步

workflow 的下一步是需要使用一个轮询或者 listener 监听请求是否被拒绝，调用WorkflowClient.CompleteActivity() 来完成这个 activity，现实世界这样做，在该实验中，会自动执行这个工作。

Prequire

语雀内容

Step

源参考

启动 dummy server
```
$ ./bin/dummy
```

如果 not found ，在 cadence-samples 目录下执行 make 命令

在另一个终端中命令，部署 workflow 和 worker
```
$ ./bin/expense -m worker
```
在另一个终端中触发工作流程
```
$ ./bin/expense -m trigger
```
查看 localhost:8099/list

如果时间较久可以发现该 workflow close 了，同时状态时显示超时。

如果你够快，那么该 workflow 中的 activity 能完成。

Analytics

Go 代码写作指导-官网

该 workflow 是用 Go 写的，下图是目录结构。

Dummy - 一个 web server

dummy 账单操作服务器，对于现实世界，应该是实际的业务服务器，同时可能负担着对于数据库的操作，在这里， Dummy server 的作用是 list expenses, create new expense, update expense state and checking expense state。路由如下：

Workflow

workflow 指导
注意：在 cadence 中 go, channel, select, time.Now(), time.Sleep() 需要使用官方提供的 sdk

Coroutine related constructs:
workflow.Go : This is a replacement for the the go statement.
workflow.Channel : This is a replacement for the native chan type. Cadence provides support for both buffered and unbuffered channels.
workflow.Selector : This is a replacement for the select statement.
Time related functions:
workflow.Now() : This is a replacement for time.Now().
workflow.Sleep() : This is a replacement for time.Sleep().

需要注册你的 workflow

查看 workflow 内容，第一步配置该 workflow 的一些配置如超时时间。

可以看到 workflow 由多个 workflow.WithActivityOptions() 来组成核心骨架，同时他们的参数createExpenseActivity表示了他们是和业务交互的部分，其他是围绕这些操作做的限制，日志，超时，判断状态等操作。
注意 workflow 中使用的信号，如最后的”COMPLETED“ 不难猜出其中使用的信号机制，可以去看这方面的源代码。

Activity

注册实际上是构造了一个函数映射表，注册了之后其他地方就能使用，如上文中的 workflow 中使用的createExpenseActivity

其中重点是 waitForDecisionActivity 的操作，这是一个异步的 Activity 因为他一开始是注定失败的，同时返回一个错误 activity.ErrResultPending 向 cadence 表明自己未完成，直到超时或者 CompleteActivity 方法被调用，在这个例子中，这个方法是在 dummy expense server 中调用的。

status := string(body)
if status == "SUCCEED" {
    // register callback succeed
    logger.Info("Successfully registered callback.", zap.String("ExpenseID", expenseID))
    // ErrActivityResultPending is returned from activity's execution to indicate the activity is not completed when it returns.
    // activity will be completed asynchronously when Client.CompleteActivity() is called.
    return "", activity.ErrResultPending
}

所以需要将这个 activity 的信息传给 dummy server

// save current activity info so it can be completed asynchronously when expense is approved/rejected
activityInfo := activity.GetInfo(ctx)
formData := url.Values{}
formData.Add("task_token", string(activityInfo.TaskToken))
registerCallbackURL := expenseServerHostPort + "/registerCallback?id=" + expenseID
resp, err := http.PostForm(registerCallbackURL, formData)
if err != nil {
    logger.Info("waitForDecisionActivity failed to register callback.", zap.Error(err))
    return "", err
}

而在 dummy server 中，当某一个账单申请被同意（approve）或者拒绝（reject）的时候，会调用对应账单的 id，找到他对应的 activity 信息并调用 CompleteActivity 方法

notifyExpenseStateChange 方法在 /action Handler 中调用

if oldState == created && (allExpense[id] == approved || allExpense[id] == rejected) {
    // report state change
    notifyExpenseStateChange(id, string(allExpense[id]))
}

Main

整个流程就是这样，开启这个 workflow，之后通过 trigger 触发这个 workflow，其中，workflow 首先创建账单，然后等待 dummy server 通知或者超时，最后完成。我们讲解了使用 cadence 如何为这个业务创建一个等幂，可控，可视的流程(workflow)

// This needs to be done as part of a bootstrap step when the process starts.
// The workers are supposed to be long running.
func startWorkers(h *common.SampleHelper) {
    // Configure worker options.
    workerOptions := worker.Options{
        MetricsScope: h.Scope,
        Logger:       h.Logger,
    }
    h.StartWorkers(h.Config.DomainName, ApplicationName, workerOptions)
}
func startWorkflow(h *common.SampleHelper, expenseID string) {
    workflowOptions := client.StartWorkflowOptions{
        ID:                              "expense_" + uuid.New(),
        TaskList:                        ApplicationName,
        ExecutionStartToCloseTimeout:    time.Minute,
        DecisionTaskStartToCloseTimeout: time.Minute,
    }
    h.StartWorkflow(workflowOptions, SampleExpenseWorkflow, expenseID)
}
func main() {
    var mode string
    flag.StringVar(&mode, "m", "trigger", "Mode is worker or trigger.")
    flag.Parse()
    var h common.SampleHelper
    h.SetupServiceConfig()
    switch mode {
    case "worker":
        startWorkers(&h)
        // The workers are supposed to be long running process that should not exit.
        // Use select{} to block indefinitely for samples, you can quit by CMD+C.
        select {}
    case "trigger":
        startWorkflow(&h, uuid.New())
    }
}